gdk_region_union
gdk_region_subtract
gdk_region_xor
+
+<SUBSECTION>
+GdkSpan
+GdkSpanFunc
+gdk_region_spans_intersect_foreach
+
</SECTION>
<SECTION>
<!-- ##### SECTION Long_Description ##### -->
<para>
-GDK provides the #GdkPoint, #GdkRectangle and #GdkRegion data types for
-representing pixels and sets of pixels on the screen.
+GDK provides the #GdkPoint, #GdkRectangle, #GdkRegion and #GdkSpan data types
+for representing pixels and sets of pixels on the screen.
</para>
<para>
#GdkPoint is a simple structure containing an x and y coordinate of a point.
#GdkRegion is an opaque data type holding a set of arbitrary pixels, and is
usually used for clipping graphical operations (see gdk_gc_set_clip_region()).
</para>
+<para>
+#GdkSpan is a structure holding a spanline. A spanline is a horizontal line that
+is one pixel wide. It is mainly used when rasterizing other graphics primitives.
+It can be intersected to regions by using gdk_region_spans_intersect_foreach().
+</para>
<!-- ##### SECTION See_Also ##### -->
<para>
@source2:
+<!-- ##### STRUCT GdkSpan ##### -->
+<para>
+
+</para>
+
+@x:
+@y:
+@width:
+
+<!-- ##### USER_FUNCTION GdkSpanFunc ##### -->
+<para>
+
+</para>
+
+@span: The intersected part of the span.
+@data: Opaque data passed by user.
+
+
+<!-- ##### FUNCTION gdk_region_spans_intersect_foreach ##### -->
+<para>
+Intersects a set of spans with a region and call a user specified
+function for each resulting spanline. This function is a lot more effective
+if the spans are sorted.
+</para>
+
+@region: The region to intersect against.
+@spans: Array of spans to intersect.
+@n_spans: Number of spans.
+@sorted: True if the spans are sorted in increasing y order.
+@function: The function to call for each intersected spanline.
+@data: Opaque user data passed to function.
+
+
GDK_OVERLAP_RECTANGLE_PART : GDK_OVERLAP_RECTANGLE_IN) :
GDK_OVERLAP_RECTANGLE_OUT);
}
+
+
+static void
+gdk_region_unsorted_spans_intersect_foreach (GdkRegion *region,
+ GdkSpan *spans,
+ int n_spans,
+ GdkSpanFunc function,
+ gpointer data)
+{
+ gint i, left, right, y;
+ gint clipped_left, clipped_right;
+ GdkRegionBox *pbox;
+ GdkRegionBox *pboxEnd;
+ GdkSpan out_span;
+
+ if (!region->numRects)
+ return;
+
+ for (i=0;i<n_spans;i++)
+ {
+ y = spans[i].y;
+ left = spans[i].x;
+ right = left + spans[i].width; /* right is not in the span! */
+
+ if (! ((region->extents.y1 <= y) &&
+ (region->extents.y2 > y) &&
+ (region->extents.x1 < right) &&
+ (region->extents.x2 > left)) )
+ continue;
+
+ /* can stop when we passed y */
+ for (pbox = region->rects, pboxEnd = pbox + region->numRects;
+ pbox < pboxEnd;
+ pbox++)
+ {
+ if (pbox->y2 <= y)
+ continue; /* Not quite there yet */
+
+ if (pbox->y1 > y)
+ break; /* passed the spanline */
+
+ if ((right > pbox->x1) && (left < pbox->x2))
+ {
+ clipped_left = MAX (left, pbox->x1);
+ clipped_right = MIN (right, pbox->x2);
+
+ out_span.y = y;
+ out_span.x = clipped_left;
+ out_span.width = clipped_right - clipped_left;
+ (*function) (&out_span, data);
+ }
+ }
+ }
+}
+
+
+void
+gdk_region_spans_intersect_foreach (GdkRegion *region,
+ GdkSpan *spans,
+ int n_spans,
+ gboolean sorted,
+ GdkSpanFunc function,
+ gpointer data)
+{
+ gint left, right, y;
+ gint clipped_left, clipped_right;
+ GdkRegionBox *pbox;
+ GdkRegionBox *pboxEnd;
+ GdkSpan *span, *tmpspan;
+ GdkSpan *end_span;
+ GdkSpan out_span;
+
+ if (!sorted)
+ {
+ gdk_region_unsorted_spans_intersect_foreach (region,
+ spans,
+ n_spans,
+ function,
+ data);
+ return;
+ }
+
+ if ((!region->numRects) || (n_spans == 0))
+ return;
+
+ y = span->y;
+ left = span->x;
+ right = span->x + span->width; /* right is not in the span! */
+
+ /* The main method here is to step along the
+ * sorted rectangles and spans in lock step, and
+ * clipping the spans that are in the current
+ * rectangle before going on to the next rectangle.
+ */
+
+ span = spans;
+ end_span = spans + n_spans;
+ pbox = region->rects;
+ pboxEnd = pbox + region->numRects;
+ while (pbox < pboxEnd)
+ {
+ while ((pbox->y2 < span->y) || (span->y < pbox->y1))
+ {
+ /* Skip any rectangles that are above the current span */
+ if (pbox->y2 < span->y)
+ {
+ pbox++;
+ if (pbox == pboxEnd)
+ return;
+ }
+ /* Skip any spans that are above the current rectangle */
+ if (span->y < pbox->y1)
+ {
+ span++;
+ if (span == end_span)
+ return;
+ }
+ }
+
+ /* Ok, we got at least one span that might intersect this rectangle. */
+ tmpspan = span;
+ while ((tmpspan < end_span) &&
+ (tmpspan->y < pbox->y2))
+ {
+ y = tmpspan->y;
+ left = tmpspan->x;
+ right = left + tmpspan->width; /* right is not in the span! */
+
+ if ((right > pbox->x1) && (left < pbox->x2))
+ {
+ clipped_left = MAX (left, pbox->x1);
+ clipped_right = MIN (right, pbox->x2);
+
+ out_span.y = y;
+ out_span.x = clipped_left;
+ out_span.width = clipped_right - clipped_left;
+ (*function) (&out_span, data);
+ }
+
+ tmpspan++;
+ }
+
+ /* Finished this rectangle.
+ * The spans could still intersect the next one
+ */
+ pbox++;
+ }
+
+ return spans;
+}
GDK_OVERLAP_RECTANGLE_PART
} GdkOverlapType;
+typedef void (*GdkSpanFunc) (GdkSpan *span,
+ gpointer data);
+
GdkRegion *gdk_region_new (void);
GdkRegion *gdk_region_polygon (GdkPoint *points,
gint npoints,
void gdk_region_xor (GdkRegion *source1,
GdkRegion *source2);
+void gdk_region_spans_intersect_foreach (GdkRegion *region,
+ GdkSpan *spans,
+ int n_spans,
+ gboolean sorted,
+ GdkSpanFunc function,
+ gpointer data);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __GDK_REGION_H__ */
+
typedef struct _GdkPoint GdkPoint;
typedef struct _GdkRectangle GdkRectangle;
typedef struct _GdkSegment GdkSegment;
+typedef struct _GdkSpan GdkSpan;
/*
* Note that on some platforms the wchar_t type
gint y2;
};
+struct _GdkSpan
+{
+ gint x;
+ gint y;
+ gint width;
+};
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
gdkinputprivate.h \
gdkinput-ps2.c \
gdkevents-fb.c \
+ gdkrender-fb.c \
mi.h \
miarc.c \
midash.c \
#include "gdkprivate-fb.h"
#include "mi.h"
-
-#include <freetype/ftglyph.h>
-
#include <string.h>
+#include <freetype/ftglyph.h>
#ifndef g_alloca
#define g_alloca alloca
#endif
-static GetPixelRet gdk_fb_drawable_get_pixel (GdkDrawable *drawable,
- GdkGC *gc,
- int x,
- int y,
- GdkColor *spot);
void gdk_fb_draw_rectangle (GdkDrawable *drawable,
GdkGC *gc,
gint filled,
GdkGC *gc,
GdkSegment *segs,
gint nsegs);
-static void gdk_fb_draw_lines (GdkDrawable *drawable,
- GdkGC *gc,
- GdkPoint *points,
- gint npoints);
static GdkColormap* gdk_fb_get_colormap (GdkDrawable *drawable);
static void gdk_fb_set_colormap (GdkDrawable *drawable,
GdkColormap *colormap);
return real_clip_region;
}
-static void
-gdk_fb_fill_span_general (GdkDrawable *drawable,
- GdkGC *gc,
- GdkSegment *cur,
- GdkColor *color)
-{
- int curx, cury;
- GdkColor spot = *color;
- GdkGCFBData *gc_private;
- GdkDrawableFBData *private;
-
- private = GDK_DRAWABLE_FBDATA (drawable);
- gc_private = GDK_GC_FBDATA (gc);
-
- g_assert (gc);
-
- {
- int clipxoff, clipyoff; /* Amounts to add to curx & cury to get x & y in clip mask */
- int tsxoff, tsyoff;
- GdkDrawable *cmask;
- guchar *clipmem;
- guint mask_rowstride;
- GdkPixmap *ts = NULL;
- GdkDrawableFBData *ts_private;
- gboolean solid_stipple;
- GdkFunction func = gc_private->values.function;
-
- cmask = gc_private->values.clip_mask;
- clipxoff = clipyoff = tsxoff = tsyoff = 0;
- mask_rowstride = 0;
- solid_stipple = FALSE;
- clipmem = NULL;
- if (cmask)
- {
- GdkDrawableFBData *cmask_private;
-
- cmask_private = GDK_DRAWABLE_IMPL_FBDATA (cmask);
-
- clipmem = cmask_private->mem;
- clipxoff = cmask_private->abs_x - gc_private->values.clip_x_origin - private->abs_x;
- clipyoff = cmask_private->abs_y - gc_private->values.clip_y_origin - private->abs_y;
- mask_rowstride = cmask_private->rowstride;
- }
-
- if (gc_private->values.fill == GDK_TILED &&
- gc_private->values.tile)
- {
- gint xstep, ystep;
- gint relx, rely;
- GdkFBDrawingContext *dc, dc_data;
- dc = &dc_data;
-
- gdk_fb_drawing_context_init (dc, drawable, gc, FALSE, TRUE);
-
- ts = gc_private->values.tile;
- ts_private = GDK_DRAWABLE_IMPL_FBDATA (ts);
- for (cury = cur->y1; cury < cur->y2; cury += ystep)
- {
- int drawh;
-
- rely = cury - private->abs_y;
- drawh = (rely + gc_private->values.ts_y_origin) % ts_private->height;
- if (drawh < 0)
- drawh += GDK_DRAWABLE_FBDATA (ts)->height;
-
- ystep = MIN (ts_private->height - drawh, cur->y2 - rely);
-
- for (curx = cur->x1; curx < cur->x2; curx += xstep)
- {
- int draww;
-
- relx = curx - private->abs_x;
-
- draww = (relx + gc_private->values.ts_x_origin) % ts_private->width;
- if (draww < 0)
- draww += ts_private->width;
-
- xstep = MIN (ts_private->width - draww, cur->x2 - relx);
-
- gdk_fb_draw_drawable_3 (drawable, gc, GDK_DRAWABLE_IMPL (ts),
- dc,
- draww, drawh,
- relx, rely,
- xstep, ystep);
- }
- }
-
- gdk_fb_drawing_context_finalize (dc);
-
- return;
- }
- else if ((gc_private->values.fill == GDK_STIPPLED ||
- gc_private->values.fill == GDK_OPAQUE_STIPPLED) &&
- gc_private->values.stipple)
- {
- ts = gc_private->values.stipple;
- tsxoff = GDK_DRAWABLE_FBDATA (ts)->abs_x - gc_private->values.ts_x_origin - private->abs_x;
- tsyoff = GDK_DRAWABLE_FBDATA (ts)->abs_y - gc_private->values.ts_y_origin - private->abs_y;
- solid_stipple = (gc_private->values.fill == GDK_OPAQUE_STIPPLED);
- }
-
- for (cury = cur->y1; cury < cur->y2; cury++)
- {
- for (curx = cur->x1; curx < cur->x2; curx++)
- {
- int maskx = curx+clipxoff, masky = cury + clipyoff;
- guchar foo;
-
- if (cmask)
- {
- foo = clipmem[masky*mask_rowstride + (maskx >> 3)];
-
- if (!(foo & (1 << (maskx % 8))))
- continue;
- }
-
- if (func == GDK_INVERT)
- {
- (gc_private->get_color) (drawable, gc, curx, cury, &spot);
- spot.pixel = ~spot.pixel;
- spot.red = ~spot.red;
- spot.green = ~spot.green;
- spot.blue = ~spot.blue;
- }
- else if (ts)
- {
- int wid, hih;
-
- ts_private = GDK_DRAWABLE_IMPL_FBDATA (ts);
-
- wid = ts_private->width;
- hih = ts_private->height;
-
- maskx = (curx+tsxoff)%wid;
- masky = (cury+tsyoff)%hih;
- if (maskx < 0)
- maskx += wid;
- if (masky < 0)
- masky += hih;
-
- foo = ts_private->mem[(maskx >> 3) + ts_private->rowstride*masky];
- if (foo & (1 << (maskx % 8)))
- {
- spot = gc_private->values.foreground;
- }
- else if (solid_stipple)
- {
- spot = gc_private->values.background;
- }
- else
- continue;
- }
-
- (gc_private->set_pixel) (drawable, gc, curx, cury, spot.pixel);
- }
- }
- }
-}
-
-static void
-gdk_fb_fill_span_simple_1 (GdkDrawable *drawable,
- GdkGC *gc,
- GdkSegment *cur,
- GdkColor *color)
-{
- int curx, cury;
- GdkGCFBData *gc_private;
- GdkDrawableFBData *private;
- guchar *mem, *ptr;
- guint rowstride;
-
- private = GDK_DRAWABLE_FBDATA (drawable);
- gc_private = GDK_GC_FBDATA (gc);
-
- g_assert (gc);
-
- g_assert (!gc_private->values.clip_mask &&
- !gc_private->values.tile &&
- !gc_private->values.stipple &&
- gc_private->values.function != GDK_INVERT);
-
- mem = private->mem;
- rowstride = private->rowstride;
-
- {
- int fromx = MIN ((cur->x1+7)&(~7), cur->x2);
- int begn = fromx - cur->x1, begoff = cur->x1 % 8, endn;
- guchar begmask, endmask;
- int body_end = cur->x2 & ~7;
- int body_len = (body_end - fromx)/8;
-
- begmask = ((1 << (begn + begoff)) - 1)
- & ~((1 << (begoff)) - 1);
- endn = cur->x2 - body_end;
- endmask = (1 << endn) - 1;
-
- for (cury = cur->y1; cury < cur->y2; cury++)
- {
- ptr = mem + cury*rowstride + (cur->x1 >> 3);
-
- if (color->pixel)
- *ptr |= begmask;
- else
- *ptr &= ~begmask;
-
- curx = fromx;
-
- if (curx < cur->x2)
- {
- ptr = mem + cury*rowstride + (curx >> 3);
- memset (ptr, color->pixel?0xFF:0, body_len);
-
- if (endn)
- {
- ptr = mem + cury*rowstride + (body_end >> 3);
- if (color->pixel)
- *ptr |= endmask;
- else
- *ptr &= ~endmask;
- }
- }
- }
- }
-}
-static void
-gdk_fb_fill_span_simple_8 (GdkDrawable *drawable,
- GdkGC *gc,
- GdkSegment *cur,
- GdkColor *color)
+struct GdkSpanHelper
{
- int cury;
- GdkGCFBData *gc_private;
- GdkDrawableFBData *private;
- guchar *mem, *ptr;
- guint rowstride;
-
- private = GDK_DRAWABLE_FBDATA (drawable);
- gc_private = GDK_GC_FBDATA (gc);
-
- g_assert (gc);
-
- g_assert (!gc_private->values.clip_mask &&
- !gc_private->values.tile &&
- !gc_private->values.stipple &&
- gc_private->values.function != GDK_INVERT);
-
- mem = private->mem;
- rowstride = private->rowstride;
-
- for (cury = cur->y1; cury < cur->y2; cury++)
- {
- ptr = mem + cury*rowstride + cur->x1;
- memset (ptr, color->pixel, cur->x2 - cur->x1);
- }
-}
-static void
-gdk_fb_fill_span_simple_16 (GdkDrawable *drawable,
- GdkGC *gc,
- GdkSegment *cur,
- GdkColor *color)
-{
- int cury;
- GdkGCFBData *gc_private;
- GdkDrawableFBData *private;
- guchar *mem;
- guint rowstride;
- int n;
- int i;
-
- private = GDK_DRAWABLE_FBDATA (drawable);
- gc_private = GDK_GC_FBDATA (gc);
-
- g_assert (gc);
-
- g_assert (!gc_private->values.clip_mask &&
- !gc_private->values.tile &&
- !gc_private->values.stipple &&
- gc_private->values.function != GDK_INVERT);
-
- mem = private->mem;
- rowstride = private->rowstride;
-
- n = cur->x2 - cur->x1;
- for (cury = cur->y1; cury < cur->y2; cury++)
- {
- guint16 *p16 = (guint16 *)(mem + cury * rowstride + cur->x1*2);
- for (i = 0; i < n; i++)
- *(p16++) = color->pixel;
- }
-}
-
-static void
-gdk_fb_fill_span_simple_24 (GdkDrawable *drawable,
- GdkGC *gc,
- GdkSegment *cur,
- GdkColor *color)
-{
- int cury;
- GdkGCFBData *gc_private;
- GdkDrawableFBData *private;
- guchar *mem, *ptr;
- guint rowstride;
- int n;
- guchar redval, greenval, blueval;
- guchar *firstline, *ptr_end;
-
- private = GDK_DRAWABLE_FBDATA (drawable);
- gc_private = GDK_GC_FBDATA (gc);
-
- g_assert (gc);
-
- g_assert (!gc_private->values.clip_mask &&
- !gc_private->values.tile &&
- !gc_private->values.stipple &&
- gc_private->values.function != GDK_INVERT);
-
- mem = private->mem;
- rowstride = private->rowstride;
+ GdkDrawable *drawable;
+ GdkGC *gc;
+ GdkColor color;
+};
- {
- redval = color->red>>8;
- greenval = color->green>>8;
- blueval = color->blue>>8;
-
- if ((cur->y2 - cur->y1) <= 0)
- return;
-
- n = (cur->x2 - cur->x1)*3;
-
- firstline = ptr = mem + cur->y1 * rowstride + cur->x1*3;
- ptr_end = ptr+n;
- while (ptr < ptr_end)
- {
- ptr[gdk_display->red_byte] = redval;
- ptr[gdk_display->green_byte] = greenval;
- ptr[gdk_display->blue_byte] = blueval;
- ptr += 3;
- }
- for (cury = cur->y1 + 1, ptr = mem + cury * rowstride + cur->x1*3; cury < cur->y2; cury++, ptr += rowstride)
- {
- memcpy (ptr, firstline, n);
- }
- }
-}
static void
-gdk_fb_fill_span_simple_32 (GdkDrawable *drawable,
- GdkGC *gc,
- GdkSegment *cur,
- GdkColor *color)
+gdk_fb_fill_span_helper(GdkSpan *span,
+ gpointer data)
{
- int cury;
- GdkGCFBData *gc_private;
- GdkDrawableFBData *private;
- guchar *mem;
- guint rowstride;
- int n;
- int i;
-
- private = GDK_DRAWABLE_FBDATA (drawable);
- gc_private = GDK_GC_FBDATA (gc);
-
- g_assert (gc);
-
- g_assert (!gc_private->values.clip_mask &&
- !gc_private->values.tile &&
- !gc_private->values.stipple &&
- gc_private->values.function != GDK_INVERT);
-
- mem = private->mem;
- rowstride = private->rowstride;
-
- n = cur->x2 - cur->x1;
- for (cury = cur->y1; cury < cur->y2; cury++)
- {
- guint32 *p32 = (guint32 *)(mem + cury * rowstride + cur->x1*4);
- for (i = 0; i < n; i++)
- *(p32++) = color->pixel;
- }
+ struct GdkSpanHelper *info = (struct GdkSpanHelper *)data;
+ GdkGC * gc = info->gc;
+
+ (GDK_GC_FBDATA (gc)->fill_span) (info->drawable, gc, span, &info->color);
}
-
-
void
gdk_fb_fill_spans (GdkDrawable *real_drawable,
GdkGC *gc,
- GdkRectangle *rects,
- int nrects)
+ GdkSpan *spans,
+ int nspans,
+ gboolean sorted)
{
int i;
- GdkColor color;
- GdkRegion *real_clip_region, *tmpreg;
- GdkRectangle draw_rect;
+ struct GdkSpanHelper info;
+ GdkRegion *real_clip_region;
gboolean handle_cursor = FALSE;
GdkDrawable *drawable;
GdkDrawableFBData *private;
-
+
drawable = real_drawable;
private = GDK_DRAWABLE_FBDATA (drawable);
+ g_assert (gc);
+
if (GDK_IS_WINDOW (private->wrapper) && !GDK_WINDOW_P (private->wrapper)->mapped)
return;
if (GDK_IS_WINDOW (private->wrapper) && GDK_WINDOW_P (private->wrapper)->input_only)
g_error ("Drawing on the evil input-only!");
- if (gc && (GDK_GC_FBDATA (gc)->values_mask & GDK_GC_FOREGROUND))
- color = GDK_GC_FBDATA (gc)->values.foreground;
+ info.drawable = drawable;
+ info.gc = gc;
+
+ if (GDK_GC_FBDATA (gc)->values_mask & GDK_GC_FOREGROUND)
+ info.color = GDK_GC_FBDATA (gc)->values.foreground;
else if (GDK_IS_WINDOW (private->wrapper))
- color = GDK_WINDOW_P (private->wrapper)->bg_color;
+ info.color = GDK_WINDOW_P (private->wrapper)->bg_color;
else
- gdk_color_black (private->colormap, &color);
+ gdk_color_black (private->colormap, &info.color);
- real_clip_region = gdk_fb_clip_region (drawable, gc, TRUE, (!gc || GDK_GC_FBDATA (gc)->values.function != GDK_INVERT));
+ real_clip_region = gdk_fb_clip_region (drawable, gc, TRUE, GDK_GC_FBDATA (gc)->values.function != GDK_INVERT);
if (private->mem == GDK_DRAWABLE_IMPL_FBDATA (gdk_parent_root)->mem &&
gdk_fb_cursor_region_need_hide (real_clip_region))
handle_cursor = TRUE;
gdk_fb_cursor_hide ();
}
-
- for (i = 0; i < nrects; i++)
- {
- GdkSegment cur;
- int j;
-
- cur.x1 = rects[i].x;
- cur.y1 = rects[i].y;
- cur.x2 = cur.x1 + rects[i].width;
- cur.y2 = cur.y1 + rects[i].height;
- g_assert (cur.x2 >= cur.x1);
- g_assert (cur.y2 >= cur.y1);
-
- cur.x1 += private->abs_x;
- cur.x1 = MAX (cur.x1, private->llim_x);
-
- cur.x2 += private->abs_x;
- cur.x2 = MIN (cur.x2, private->lim_x);
- cur.x1 = MIN (cur.x1, cur.x2);
-
- cur.y1 += private->abs_y;
- cur.y1 = MAX (cur.y1, private->llim_y);
-
- cur.y2 += private->abs_y;
- cur.y2 = MIN (cur.y2, private->lim_y);
- cur.y1 = MIN (cur.y1, cur.y2);
- draw_rect.x = cur.x1;
- draw_rect.y = cur.y1;
- draw_rect.width = cur.x2 - cur.x1;
- draw_rect.height = cur.y2 - cur.y1;
+ for (i = 0; i < nspans; i++)
+ {
+ GdkSpan *cur;
+
+ cur = &spans[i];
+
+ cur->x += private->abs_x;
+ cur->y += private->abs_y;
- switch (gdk_region_rect_in (real_clip_region, &draw_rect))
+ if ( (cur->y < private->llim_y) || (cur->y >= private->lim_y))
+ cur->width = 0;
+
+ if (cur->x < private->llim_x)
{
- case GDK_OVERLAP_RECTANGLE_PART:
- tmpreg = gdk_region_rectangle (&draw_rect);
- gdk_region_intersect (tmpreg, real_clip_region);
- for (j = 0; j < tmpreg->numRects; j++)
- {
- cur = tmpreg->rects[j];
- (GDK_GC_FBDATA (gc)->fill_span) (drawable, gc, &cur, &color);
- }
- gdk_region_destroy (tmpreg);
- break;
- case GDK_OVERLAP_RECTANGLE_IN:
- (GDK_GC_FBDATA (gc)->fill_span) (drawable, gc, &cur, &color);
- break;
- default:
- break;
+ cur->width -= private->llim_x - cur->x;
+ cur->x = private->llim_x;
+ }
+
+ if (cur->x + cur->width > private->lim_x)
+ {
+ cur->width = private->lim_x - cur->x;
}
+
+ if (cur->width <= 0)
+ cur->width = 0;
}
+ gdk_region_spans_intersect_foreach (real_clip_region,
+ spans,
+ nspans,
+ sorted,
+ gdk_fb_fill_span_helper,
+ &info);
+
gdk_region_destroy (real_clip_region);
if (handle_cursor)
gdk_fb_cursor_unhide ();
}
-static GetPixelRet
-gdk_fb_drawable_get_pixel (GdkDrawable *drawable,
- GdkGC *gc,
- int x,
- int y,
- GdkColor *spot)
-{
- GetPixelRet retval = GPR_NONE;
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- guchar *mem = private->mem;
- guint rowstride = private->rowstride;
-
- switch (private->depth)
- {
- case 1:
- {
- guchar foo = mem[(x >> 3) + y * rowstride];
- if (foo & (1 << (x % 8)))
- *spot = GDK_GC_FBDATA (gc)->values.foreground;
- else
- {
- retval = GPR_USED_BG;
- *spot = GDK_GC_FBDATA (gc)->values.background;
- }
- }
- break;
- case 71:
- if (mem[x + y * rowstride])
- *spot = GDK_GC_FBDATA (gc)->values.foreground;
- else
- *spot = GDK_GC_FBDATA (gc)->values.background;
- break;
- case 77:
- retval = GPR_AA_GRAYVAL;
- spot->pixel = mem[x + y * rowstride] << 1;
- spot->red = spot->green = spot->blue = spot->pixel << 8;
- break;
- case 78: /* AA mode */
- retval = GPR_AA_GRAYVAL;
- spot->pixel = mem[x + y * rowstride];
- spot->red = spot->green = spot->blue = spot->pixel << 8;
- break;
- case 8:
- spot->pixel = mem[x + y * rowstride];
- *spot = private->colormap->colors[spot->pixel];
- break;
- case 16:
- {
- guint16 val16 = *((guint16 *)&mem[x*2 + y*rowstride]);
-
- spot->red = (((1<<gdk_display->modeinfo.red.length) - 1) & (val16 >> gdk_display->modeinfo.red.offset)) << (16 - gdk_display->modeinfo.red.length);
- spot->green = (((1<<gdk_display->modeinfo.green.length) - 1) & (val16 >> gdk_display->modeinfo.green.offset)) << (16 - gdk_display->modeinfo.green.length);
- spot->blue = (((1<<gdk_display->modeinfo.blue.length) - 1) & (val16 >> gdk_display->modeinfo.blue.offset)) << (16 - gdk_display->modeinfo.blue.length);
-
- spot->pixel = val16;
- }
- break;
- case 24:
- {
- guchar *smem = &mem[x*3 + y*rowstride];
- spot->red = smem[gdk_display->red_byte] << 8;
- spot->green = smem[gdk_display->green_byte] << 8;
- spot->blue = smem[gdk_display->blue_byte] << 8;
-#if (G_BYTE_ORDER == G_BIG_ENDIAN)
- spot->pixel = (smem[0]<<16)|(smem[1]<<8)|smem[2];
-#else
- spot->pixel = smem[0]|(smem[1]<<8)|(smem[2]<<16);
-#endif
- }
- break;
- case 32:
- {
- guchar *smem = &mem[x*4 + y*rowstride];
- spot->red = smem[gdk_display->red_byte] << 8;
- spot->green = smem[gdk_display->green_byte] << 8;
- spot->blue = smem[gdk_display->blue_byte] << 8;
- spot->pixel = *(guint32 *)smem;
- }
- break;
- }
-
- return retval;
-}
-
-static void
-gdk_fb_drawable_set_pixel_1(GdkDrawable *drawable,
- GdkGC *gc,
- int x,
- int y,
- gulong pixel)
-{
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- guchar *mem = private->mem;
- guint rowstride = private->rowstride;
- guchar *ptr;
-
- g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
-
- ptr = mem + (y*rowstride) + (x >> 3);
-
- if (pixel)
- *ptr |= (1 << (x % 8));
- else
- *ptr &= ~(1 << (x % 8));
-}
-
-static void
-gdk_fb_drawable_set_pixel_8(GdkDrawable *drawable,
- GdkGC *gc,
- int x,
- int y,
- gulong pixel)
-{
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- guchar *mem = private->mem;
- guint rowstride = private->rowstride;
-
- g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
-
- mem[x + y*rowstride] = pixel;
-}
-
-static void
-gdk_fb_drawable_set_pixel_16(GdkDrawable *drawable,
- GdkGC *gc,
- int x,
- int y,
- gulong pixel)
-{
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- guchar *mem = private->mem;
- guint rowstride = private->rowstride;
- guint16 *ptr;
-
- g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
-
- ptr = (guint16 *)&mem[x*2 + y*rowstride];
- *ptr = pixel;
-}
-
-static void
-gdk_fb_drawable_set_pixel_24(GdkDrawable *drawable,
- GdkGC *gc,
- int x,
- int y,
- gulong pixel)
-{
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- guchar *mem = private->mem;
- guint rowstride = private->rowstride;
- guchar *smem;
-
- g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
-
- smem = &mem[x*3 + y*rowstride];
- smem[0] = pixel & 0xff;
- smem[1] = (pixel >> 8) & 0xff;
- smem[2] = (pixel >> 16) & 0xff;
-}
-
-static void
-gdk_fb_drawable_set_pixel_32(GdkDrawable *drawable,
- GdkGC *gc,
- int x,
- int y,
- gulong pixel)
-{
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- guchar *mem = private->mem;
- guint rowstride = private->rowstride;
- guint32 *smem;
-
- g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
-
- smem = (guint32 *)&mem[x*4 + y*rowstride];
- *smem = pixel;
-}
-
-
-static GetPixelRet
-gdk_fb_drawable_get_color_1 (GdkDrawable *drawable,
- GdkGC *gc,
- int x,
- int y,
- GdkColor *color)
-{
- GetPixelRet retval = GPR_NONE;
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- guchar *mem = private->mem;
- guint rowstride = private->rowstride;
- guchar foo;
-
- g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
-
- foo = mem[(x >> 3) + y * rowstride];
- if (foo & (1 << (x % 8)))
- *color = GDK_GC_FBDATA (gc)->values.foreground;
- else
- {
- retval = GPR_USED_BG;
-
- *color = GDK_GC_FBDATA (gc)->values.background;
- }
-
- return retval;
-}
-
-static GetPixelRet
-gdk_fb_drawable_get_color_8 (GdkDrawable *drawable,
- GdkGC *gc,
- int x,
- int y,
- GdkColor *color)
-{
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- guchar *mem = private->mem;
- guint rowstride = private->rowstride;
- gint pixel;
-
- g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
-
- pixel = mem[x + y * rowstride];
- *color = private->colormap->colors[pixel];
-
- return GPR_NONE;
-}
-static GetPixelRet
-gdk_fb_drawable_get_color_16 (GdkDrawable *drawable,
- GdkGC *gc,
- int x,
- int y,
- GdkColor *color)
-{
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- guchar *mem = private->mem;
- guint rowstride = private->rowstride;
- guint16 val16;
-
- g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
-
- val16 = *((guint16 *)&mem[x*2 + y*rowstride]);
-
- color->red = (((1<<gdk_display->modeinfo.red.length) - 1) & (val16 >> gdk_display->modeinfo.red.offset)) << (16 - gdk_display->modeinfo.red.length);
- color->green = (((1<<gdk_display->modeinfo.green.length) - 1) & (val16 >> gdk_display->modeinfo.green.offset)) << (16 - gdk_display->modeinfo.green.length);
- color->blue = (((1<<gdk_display->modeinfo.blue.length) - 1) & (val16 >> gdk_display->modeinfo.blue.offset)) << (16 - gdk_display->modeinfo.blue.length);
-
- color->pixel = val16;
-
- return GPR_NONE;
-}
-
-static GetPixelRet
-gdk_fb_drawable_get_color_24 (GdkDrawable *drawable,
- GdkGC *gc,
- int x,
- int y,
- GdkColor *color)
-{
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- guchar *mem = private->mem;
- guint rowstride = private->rowstride;
- guchar *smem;
-
- g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
-
- smem = &mem[x*3 + y*rowstride];
- color->red = smem[gdk_display->red_byte] << 8;
- color->green = smem[gdk_display->green_byte] << 8;
- color->blue = smem[gdk_display->blue_byte] << 8;
-#if (G_BYTE_ORDER == G_BIG_ENDIAN)
- color->pixel = (smem[0]<<16)|(smem[1]<<8)|smem[2];
-#else
- color->pixel = smem[0]|(smem[1]<<8)|(smem[2]<<16);
-#endif
-
- return GPR_NONE;
-}
-
-static GetPixelRet
-gdk_fb_drawable_get_color_32 (GdkDrawable *drawable,
- GdkGC *gc,
- int x,
- int y,
- GdkColor *color)
-{
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- guchar *mem = private->mem;
- guint rowstride = private->rowstride;
- guchar *smem;
-
- g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
-
- smem = &mem[x*4 + y*rowstride];
- color->red = smem[gdk_display->red_byte] << 8;
- color->green = smem[gdk_display->green_byte] << 8;
- color->blue = smem[gdk_display->blue_byte] << 8;
- color->pixel = *(guint32 *)smem;
-
- return GPR_NONE;
-}
-
void
gdk_fb_drawing_context_init (GdkFBDrawingContext *dc,
GdkDrawable *drawable,
gdk_fb_cursor_unhide ();
}
-void
-gdk_fb_draw_drawable_memmove (GdkDrawable *drawable,
- GdkGC *gc,
- GdkPixmap *src,
- GdkFBDrawingContext *dc,
- gint start_y,
- gint end_y,
- gint start_x,
- gint end_x,
- gint src_x_off,
- gint src_y_off,
- gint draw_direction)
-{
- GdkDrawableFBData *src_private = GDK_DRAWABLE_FBDATA (src);
- guint depth = src_private->depth;
- guint src_rowstride = src_private->rowstride;
- guchar *srcmem = src_private->mem;
- int linelen = (end_x - start_x)*(depth>>3);
- gint cur_y;
-
- for(cur_y = start_y; cur_y*draw_direction < end_y*draw_direction; cur_y += draw_direction)
- {
- memmove (dc->mem + (cur_y * dc->rowstride) + start_x*(depth>>3),
- srcmem + ((cur_y + src_y_off)*src_rowstride) + (start_x + src_x_off)*(depth>>3),
- linelen);
- }
-
-}
-
-
-void
-gdk_fb_draw_drawable_generic (GdkDrawable *drawable,
- GdkGC *gc,
- GdkPixmap *src,
- GdkFBDrawingContext *dc,
- gint start_y,
- gint end_y,
- gint start_x,
- gint end_x,
- gint src_x_off,
- gint src_y_off,
- gint draw_direction)
-{
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- int cur_x, cur_y;
-
- for (cur_y = start_y; cur_y*draw_direction < end_y*draw_direction; cur_y+=draw_direction)
- {
- for (cur_x = start_x; cur_x < end_x; cur_x++)
- {
- GdkColor spot;
-
- if (GDK_GC_FBDATA(gc)->values.clip_mask)
- {
- int maskx = cur_x + dc->clipxoff, masky = cur_y + dc->clipyoff;
- guchar foo;
-
- foo = dc->clipmem[masky*dc->clip_rowstride + (maskx >> 3)];
-
- if (!(foo & (1 << (maskx % 8))))
- continue;
- }
-
- switch (gdk_fb_drawable_get_pixel (src, gc, cur_x + src_x_off, cur_y + src_y_off, &spot))
- {
- case GPR_AA_GRAYVAL:
- {
- GdkColor realspot, fg;
- guint graylevel = spot.pixel;
- gint tmp;
-
- if (private->depth == 1)
- {
- if (spot.pixel > 192)
- spot = GDK_GC_FBDATA (gc)->values.foreground;
- else
- spot = GDK_GC_FBDATA (gc)->values.background;
- break;
- }
- else
- {
- if (graylevel >= 254)
- {
- spot = GDK_GC_FBDATA (gc)->values.foreground;
- }
- else if (graylevel <= 2)
- {
- if (!dc->draw_bg)
- continue;
-
- spot = GDK_GC_FBDATA (gc)->values.background;
- }
- else
- {
- switch ((GDK_GC_FBDATA (gc)->get_color) (drawable, gc, cur_x, cur_y, &realspot))
- {
- case GPR_USED_BG:
- {
- int bgx, bgy;
-
- bgx = (cur_x - GDK_DRAWABLE_IMPL_FBDATA (dc->bg_relto)->abs_x) % GDK_DRAWABLE_IMPL_FBDATA (dc->bgpm)->width + private->abs_x;
- bgy = (cur_y - GDK_DRAWABLE_IMPL_FBDATA (dc->bg_relto)->abs_y) % GDK_DRAWABLE_IMPL_FBDATA (dc->bgpm)->height + private->abs_y;
- gdk_fb_drawable_get_pixel (dc->bgpm, gc, bgx, bgy, &realspot);
- }
- break;
- case GPR_NONE:
- break;
- default:
- g_assert_not_reached ();
- break;
- }
-
- fg = GDK_GC_FBDATA (gc)->values.foreground;
-
- /* Now figure out what 'spot' should actually look like */
- fg.red >>= 8;
- fg.green >>= 8;
- fg.blue >>= 8;
- realspot.red >>= 8;
- realspot.green >>= 8;
- realspot.blue >>= 8;
-
-
- tmp = (fg.red - realspot.red) * graylevel;
- spot.red = realspot.red + ((tmp + (tmp >> 8) + 0x80) >> 8);
- spot.red <<= 8;
-
- tmp = (fg.green - realspot.green) * graylevel;
- spot.green = realspot.green + ((tmp + (tmp >> 8) + 0x80) >> 8);
- spot.green <<= 8;
-
- tmp = (fg.blue - realspot.blue) * graylevel;
- spot.blue = realspot.blue + ((tmp + (tmp >> 8) + 0x80) >> 8);
- spot.blue <<= 8;
-
- /* Now find the pixel for this thingie */
- switch (private->depth)
- {
- case 8:
- if (!gdk_colormap_alloc_color (private->colormap, &spot, FALSE, TRUE))
- {
- g_error ("Can't allocate AA color!");
- }
- break;
- case 16:
- spot.pixel = (spot.red >> (16 - gdk_display->modeinfo.red.length)) << gdk_display->modeinfo.red.offset;
- spot.pixel |= (spot.green >> (16 - gdk_display->modeinfo.green.length)) << gdk_display->modeinfo.green.offset;
- spot.pixel |= (spot.blue >> (16 - gdk_display->modeinfo.blue.length)) << gdk_display->modeinfo.blue.offset;
- break;
- case 24:
- case 32:
- spot.pixel = ((spot.red & 0xFF00) >> 8 << (gdk_display->modeinfo.red.offset))
- | ((spot.green & 0xFF00) >> 8 << (gdk_display->modeinfo.green.offset))
- | ((spot.blue & 0xFF00) >> 8 << (gdk_display->modeinfo.blue.offset));
- break;
- }
- }
- }
- }
- break;
- case GPR_USED_BG:
- if (!dc->draw_bg)
- continue;
- break;
- case GPR_NONE:
- break;
- default:
- g_assert_not_reached ();
- break;
- }
-
- (GDK_GC_FBDATA (gc)->set_pixel) (drawable, gc, cur_x, cur_y, spot.pixel);
- }
- }
-
-}
-
void
gdk_fb_draw_drawable_2 (GdkDrawable *drawable,
GdkGC *gc,
}
-static void
-gdk_fb_draw_drawable_aa_24 (GdkDrawable *drawable,
- GdkGC *gc,
- GdkPixmap *src,
- GdkFBDrawingContext *dc,
- gint start_y,
- gint end_y,
- gint start_x,
- gint end_x,
- gint src_x_off,
- gint src_y_off,
- gint draw_direction)
-{
- GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
- int x, y;
- GdkGCFBData *gc_private;
- guchar *dmem = private->mem;
- guint dst_rowstride = private->rowstride;
- guchar *smem = GDK_DRAWABLE_FBDATA (src)->mem;
- guint src_rowstride = GDK_DRAWABLE_FBDATA (src)->rowstride;
- guchar *dst;
- guint grayval;
- gint r, g, b, tmp;
- GdkColor fg;
- gint fg_r, fg_g, fg_b;
-
- gc_private = GDK_GC_FBDATA (gc);
-
- fg = GDK_GC_FBDATA (gc)->values.foreground;
- fg_r = fg.red >> 8;
- fg_g = fg.green >> 8;
- fg_b = fg.blue >> 8;
-
- for (y = start_y; y*draw_direction < end_y*draw_direction; y+=draw_direction)
- {
- for (x = start_x; x < end_x; x++)
- {
- grayval = smem[x + src_x_off + (y + src_y_off) * src_rowstride];
-
- if ((grayval <= 2) && (!dc->draw_bg))
- continue;
-
- dst = &dmem[x*3 + y*dst_rowstride];
-
- if (grayval >= 254)
- {
- dst[gdk_display->red_byte] = fg_r;
- dst[gdk_display->green_byte] = fg_g;
- dst[gdk_display->blue_byte] = fg_b;
- }
- else if (grayval <= 2)
- {
- dst[gdk_display->red_byte] = GDK_GC_FBDATA (gc)->values.background.red >> 8;
- dst[gdk_display->green_byte] = GDK_GC_FBDATA (gc)->values.background.green >> 8;
- dst[gdk_display->blue_byte] = GDK_GC_FBDATA (gc)->values.background.blue >> 8;
- }
- else
- {
- r = dst[gdk_display->red_byte];
- tmp = (fg_r - r) * (gint)grayval;
- r = r + ((tmp + (tmp >> 8) + 0x80) >> 8);
- dst[gdk_display->red_byte] = r;
-
- g = dst[gdk_display->green_byte];
- tmp = (fg_g - g) * (gint)grayval;
- g = g + ((tmp + (tmp >> 8) + 0x80) >> 8);
- dst[gdk_display->green_byte] = g;
-
- b = dst[gdk_display->blue_byte];
- tmp = (fg_b - b) * (gint)grayval;
- b = b + ((tmp + (tmp >> 8) + 0x80) >> 8);
- dst[gdk_display->blue_byte] = b;
- }
- }
- }
-}
-
-
-void
-_gdk_fb_gc_calc_state (GdkGC *gc,
- GdkGCValuesMask changed)
-{
- GdkGCFBData *gc_private;
- int i;
-
- gc_private = GDK_GC_FBDATA (gc);
-
- gc_private->fill_span = gdk_fb_fill_span_general;
-
- for (i=0;i<GDK_NUM_FB_SRCBPP;i++)
- gc_private->draw_drawable[i] = gdk_fb_draw_drawable_generic;
-
- if (changed & _GDK_FB_GC_DEPTH)
- switch (gc_private->depth)
- {
- case 1:
- gc_private->set_pixel = gdk_fb_drawable_set_pixel_1;
- gc_private->get_color = gdk_fb_drawable_get_color_1;
- break;
- case 8:
- gc_private->set_pixel = gdk_fb_drawable_set_pixel_8;
- gc_private->get_color = gdk_fb_drawable_get_color_8;
- break;
- case 16:
- gc_private->set_pixel = gdk_fb_drawable_set_pixel_16;
- gc_private->get_color = gdk_fb_drawable_get_color_16;
- break;
- case 24:
- gc_private->set_pixel = gdk_fb_drawable_set_pixel_24;
- gc_private->get_color = gdk_fb_drawable_get_color_24;
- break;
- case 32:
- gc_private->set_pixel = gdk_fb_drawable_set_pixel_32;
- gc_private->get_color = gdk_fb_drawable_get_color_32;
- break;
- default:
- g_assert_not_reached ();
- break;
- }
-
- if (!gc_private->values.clip_mask)
- {
- switch (gc_private->depth)
- {
- case 8:
- gc_private->draw_drawable[GDK_FB_SRC_BPP_8] = gdk_fb_draw_drawable_memmove;
- break;
- case 16:
- gc_private->draw_drawable[GDK_FB_SRC_BPP_16] = gdk_fb_draw_drawable_memmove;
- break;
- case 24:
- if (getenv("foo") && strcmp(getenv("foo"), "bar")==0)
- gc_private->draw_drawable[GDK_FB_SRC_BPP_8_AA_GRAYVAL] = gdk_fb_draw_drawable_aa_24;
- gc_private->draw_drawable[GDK_FB_SRC_BPP_24] = gdk_fb_draw_drawable_memmove;
- break;
- case 32:
- gc_private->draw_drawable[GDK_FB_SRC_BPP_32] = gdk_fb_draw_drawable_memmove;
- break;
- }
-
- }
-
-
- if (!gc_private->values.clip_mask &&
- !gc_private->values.tile &&
- !gc_private->values.stipple &&
- gc_private->values.function != GDK_INVERT)
- {
- switch (gc_private->depth)
- {
- case 1:
- gc_private->fill_span = gdk_fb_fill_span_simple_1;
- break;
- case 8:
- gc_private->fill_span = gdk_fb_fill_span_simple_8;
- break;
- case 16:
- gc_private->fill_span = gdk_fb_fill_span_simple_16;
- break;
- case 24:
- gc_private->fill_span = gdk_fb_fill_span_simple_24;
- break;
- case 32:
- gc_private->fill_span = gdk_fb_fill_span_simple_32;
- break;
- default:
- g_assert_not_reached ();
- break;
- }
- }
-
-}
static void
gint width,
gint height)
{
- GdkRectangle rect;
-
+ GdkDrawableFBData *private;
+
+ private = GDK_DRAWABLE_FBDATA (drawable);
+
if (filled)
{
- rect.x = x;
- rect.y = y;
- rect.width = width;
- rect.height = height;
- gdk_fb_fill_spans (drawable, gc, &rect, 1);
+ gboolean handle_cursor = FALSE;
+ GdkRectangle tmprect;
+ GdkRegion *tmpreg;
+ GdkRegion *real_clip_region;
+ GdkColor color;
+ int i;
+
+ if (GDK_GC_FBDATA (gc)->values_mask & GDK_GC_FOREGROUND)
+ color = GDK_GC_FBDATA (gc)->values.foreground;
+ else if (GDK_IS_WINDOW (private->wrapper))
+ color = GDK_WINDOW_P (private->wrapper)->bg_color;
+ else
+ gdk_color_black (private->colormap, &color);
+
+ real_clip_region = gdk_fb_clip_region (drawable, gc, TRUE, GDK_GC_FBDATA (gc)->values.function != GDK_INVERT);
+
+ if (private->mem == GDK_DRAWABLE_IMPL_FBDATA (gdk_parent_root)->mem &&
+ gdk_fb_cursor_region_need_hide (real_clip_region))
+ {
+ handle_cursor = TRUE;
+ gdk_fb_cursor_hide ();
+ }
+
+ x += private->abs_x;
+ y += private->abs_y;
+
+ if (x < private->llim_x)
+ {
+ width -= private->llim_x - x;
+ x = private->llim_x;
+ }
+ if (x + width > private->lim_x)
+ width = private->lim_x - x;
+
+ if (y < private->llim_y)
+ {
+ height -= private->llim_y - y;
+ y = private->llim_y;
+ }
+ if (y + height > private->lim_y)
+ height = private->lim_y - y;
+
+ tmprect.x = x;
+ tmprect.y = y;
+ tmprect.width = width;
+ tmprect.height = height;
+ tmpreg = gdk_region_rectangle (&tmprect);
+
+ gdk_region_intersect (tmpreg, real_clip_region);
+
+ for (i = 0; i < tmpreg->numRects; i++)
+ {
+ GdkRectangle r;
+ r.x = tmpreg->rects[i].x1;
+ r.y = tmpreg->rects[i].y1;
+ r.width = tmpreg->rects[i].x2 - tmpreg->rects[i].x1;
+ r.height = tmpreg->rects[i].y2 - tmpreg->rects[i].y1;
+
+ if ((r.width > 0) && (r.height > 0))
+ (GDK_GC_FBDATA (gc)->fill_rectangle) (drawable, gc, &r, &color);
+ }
+
+ gdk_region_destroy (tmpreg);
+
+ gdk_region_destroy (real_clip_region);
+ if (handle_cursor)
+ gdk_fb_cursor_unhide ();
}
else
{
GdkPoint pts[5];
+
pts[0].x = pts[4].x = x;
pts[0].y = pts[4].y = y;
pts[1].x = x + width;
pts[3].y = y + height;
gdk_fb_draw_lines (drawable, gc, pts, 5);
}
+
}
static void
GdkPoint *points,
gint npoints)
{
- GdkRectangle *rects = g_alloca (npoints * sizeof(GdkRectangle));
+ GdkSpan *spans = g_alloca (npoints * sizeof(GdkSpan));
int i;
for (i = 0; i < npoints; i++)
{
- rects[i].x = points[i].x;
- rects[i].y = points[i].y;
- rects[i].width = rects[i].height = 1;
+ spans[i].x = points[i].x;
+ spans[i].y = points[i].y;
+ spans[i].width = 1;
}
- gdk_fb_fill_spans (drawable, gc, rects, npoints);
+ gdk_fb_fill_spans (drawable, gc, spans, npoints, FALSE);
}
static void
}
}
-static void
+void
gdk_fb_draw_lines (GdkDrawable *drawable,
GdkGC *gc,
GdkPoint *points,
#include "gdkinternals.h"
#include "gdkfb.h"
-#include "gdkkeysyms.h"
-
-#if HAVE_CONFIG_H
-# include <config.h>
-# if STDC_HEADERS
-# include <string.h>
-# endif
-#endif
-
-typedef struct _GdkIOClosure GdkIOClosure;
-typedef struct _GdkEventPrivate GdkEventPrivate;
-
-#define DOUBLE_CLICK_TIME 250
-#define TRIPLE_CLICK_TIME 500
-#define DOUBLE_CLICK_DIST 5
-#define TRIPLE_CLICK_DIST 5
-
-typedef enum
-{
- /* Following flag is set for events on the event queue during
- * translation and cleared afterwards.
- */
- GDK_EVENT_PENDING = 1 << 0
-} GdkEventFlags;
-
-struct _GdkIOClosure
-{
- GdkInputFunction function;
- GdkInputCondition condition;
- GdkDestroyNotify notify;
- gpointer data;
-};
-
-struct _GdkEventPrivate
-{
- GdkEvent event;
- guint flags;
-};
-
-/*
- * Private function declarations
- */
-
-/* Private variable declarations
- */
-
-#if 0
-static GList *client_filters; /* Filters for client messages */
-
-static GSourceFuncs event_funcs = {
- gdk_event_prepare,
- gdk_event_check,
- gdk_event_dispatch,
- (GDestroyNotify)g_free
-};
-#endif
-
/*********************************************
* Functions for maintaining the event queue *
*********************************************/
GTimeVal *dispatch_time,
gpointer user_data);
+guint32
+gdk_fb_get_time(void)
+{
+ GTimeVal tv;
+
+ g_get_current_time (&tv);
+ return (guint32) tv.tv_sec * 1000 + tv.tv_usec / 1000;
+}
+
void
gdk_events_init (void)
{
static MouseDevice *gdk_fb_mouse = NULL;
static Keyboard *keyboard = NULL;
-static guint multiclick_tag;
-static GdkEvent *multiclick_event = NULL;
-
#ifndef VESA_NO_BLANKING
#define VESA_NO_BLANKING 0
#define VESA_VSYNC_SUSPEND 1
#endif
}
-static gboolean
-click_event_timeout (gpointer x)
-{
- switch (multiclick_event->type)
- {
- case GDK_BUTTON_RELEASE:
- gdk_event_free (multiclick_event);
- break;
- case GDK_2BUTTON_PRESS:
- case GDK_3BUTTON_PRESS:
- gdk_event_queue_append (multiclick_event);
- break;
- default:
- break;
- }
-
- multiclick_event = NULL;
- multiclick_tag = 0;
-
- return FALSE;
-}
-
static void
send_button_event (MouseDevice *mouse,
guint button,
gboolean press_event,
- time_t the_time)
+ guint32 the_time)
{
GdkEvent *event;
gint x, y;
x = mouse->x - x;
y = mouse->y - y;
- if (!press_event &&
- multiclick_event &&
- multiclick_event->button.button == button &&
- multiclick_event->button.window == window &&
- ABS(multiclick_event->button.x - x) < 3 &&
- ABS(multiclick_event->button.y - y) < 3)
- {
- multiclick_event->button.time = the_time;
-
- /* Just change multiclick_event into a different event */
- switch (multiclick_event->button.type)
- {
- default:
- g_assert_not_reached ();
-
- case GDK_BUTTON_RELEASE:
- multiclick_event->button.type = GDK_2BUTTON_PRESS;
- return;
-
- case GDK_2BUTTON_PRESS:
- multiclick_event->button.type = GDK_3BUTTON_PRESS;
- return;
-
- case GDK_3BUTTON_PRESS:
- gdk_event_queue_append (multiclick_event); multiclick_event = NULL;
- g_source_remove (multiclick_tag); multiclick_tag = 0;
- }
- }
-
event = gdk_event_make (window, press_event ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE, FALSE);
if (!event)
mouse->click_grab = FALSE;
}
+ event->button.time = the_time;
+
#if 0
g_message ("Button #%d %s [%d, %d] in %p",
button, press_event?"pressed":"released",
}
#endif
- if (!press_event && !multiclick_tag)
- {
- multiclick_tag = g_timeout_add (250, click_event_timeout, NULL);
- multiclick_event = gdk_event_copy (event);
- }
+ /* For double-clicks */
+ if (press_event)
+ gdk_event_button_generate (event);
gdk_event_queue_append (event);
}
event->motion.device = gdk_core_pointer;
event->motion.x_root = mouse->x;
event->motion.y_root = mouse->y;
+ event->motion.time = gdk_fb_get_time ();
}
if (win != mouse->prev_window)
gdouble x, y, oldx, oldy;
gboolean got_motion = FALSE;
gboolean btn_down;
- time_t the_time;
- GTimeVal tv;
+ guint32 the_time;
- g_get_current_time (&tv);
- the_time = tv.tv_sec;
+ the_time = gdk_fb_get_time ();
+
oldx = mouse->x;
oldy = mouse->y;
while (pull_fidmour_packet (mouse, &btn_down, &x, &y))
MouseDevice *mouse = data;
int n, dx=0, dy=0;
gboolean new_button1, new_button2, new_button3;
- time_t the_time;
- GTimeVal curtime;
+ guint32 the_time;
gboolean got_motion = FALSE;
guchar *buf;
- g_get_current_time (&curtime);
- the_time = curtime.tv_usec;
+ the_time = gdk_fb_get_time ();
while (1) /* Go through as many mouse events as we can */
{
guchar byte1, byte2, byte3;
int n, dx=0, dy=0;
gboolean new_button1, new_button2, new_button3;
- time_t the_time;
- GTimeVal curtime;
+ guint32 the_time;
- g_get_current_time (&curtime);
- the_time = curtime.tv_usec;
+ the_time = gdk_fb_get_time ();
n = read (mouse->fd, &byte1, 1);
if ( (n!=1) || (byte1 & 0x40) != 0x40)
guchar buf[128];
int i, n;
Keyboard *k = data;
- time_t now;
- GTimeVal curtime;
+ guint32 now;
n = read (k->fd, buf, sizeof(buf));
if (n <= 0)
g_error("Nothing from keyboard!");
/* Now turn this into a keyboard event */
- g_get_current_time (&curtime);
- now = curtime.tv_sec;
+ now = gdk_fb_get_time ();
for (i = 0; i < n; i++)
{
guchar buf[128];
int i, n;
Keyboard *k = data;
- time_t now;
- GTimeVal curtime;
+ guint32 now;
n = read (k->fd, buf, sizeof(buf));
if (n <= 0)
g_error ("Nothing from keyboard!");
/* Now turn this into a keyboard event */
- g_get_current_time (&curtime);
- now = curtime.tv_sec;
+ now = gdk_fb_get_time ();
for (i = 0; i < n; i++)
{
guint32 the_time = g_latest_time.tv_sec * 1000 + g_latest_time.tv_usec / 1000;
#else
guint32 the_time;
- GTimeVal gcurtime;
- g_get_current_time (&gcurtime);
- the_time = gcurtime.tv_sec * 1000 + gcurtime.tv_usec / 1000;
+
+ the_time = gdk_fb_get_time ();
#endif
event->any.type = type;
/* These functions can only be called for drawables
* that have the same depth as the gc.
*/
- void (*set_pixel) (GdkDrawable *drawable,
+ void (*set_pixel) (GdkDrawable *drawable,
GdkGC *gc,
int x,
int y,
int y,
GdkColor *color);
- void (*fill_span) (GdkDrawable *drawable,
- GdkGC *gc,
- GdkSegment *cur,
- GdkColor *color);
-
+ void (*fill_span) (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkSpan *span,
+ GdkColor *color);
+
+ void (*fill_rectangle) (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkRectangle *rect,
+ GdkColor *color);
+
gdk_fb_draw_drawable_func *draw_drawable[GDK_NUM_FB_SRCBPP];
} GdkGCFBData;
gboolean handle_cursor : 1;
};
-void gdk_fb_drawing_context_init(GdkFBDrawingContext *dc, GdkDrawable *drawable,
- GdkGC *gc, gboolean draw_bg, gboolean do_clipping);
-void gdk_fb_drawing_context_finalize(GdkFBDrawingContext *dc);
-
-void gdk_fb_draw_drawable_3 (GdkDrawable *drawable,
- GdkGC *gc,
- GdkPixmap *src,
- GdkFBDrawingContext *dc,
- gint xsrc,
- gint ysrc,
- gint xdest,
- gint ydest,
- gint width,
- gint height);
-
-void gdk_fb_draw_drawable_2 (GdkDrawable *drawable,
- GdkGC *gc,
- GdkPixmap *src,
- gint xsrc,
- gint ysrc,
- gint xdest,
- gint ydest,
- gint width,
- gint height,
- gboolean draw_bg,
- gboolean do_clipping);
-void gdk_fb_draw_rectangle (GdkDrawable *drawable,
- GdkGC *gc,
- gint filled,
- gint x,
- gint y,
- gint width,
- gint height);
-void gdk_fb_fill_spans(GdkDrawable *real_drawable, GdkGC *gc, GdkRectangle *rects, int nrects);
-GdkRegion *gdk_fb_clip_region(GdkDrawable *drawable, GdkGC *gc, gboolean do_clipping, gboolean do_children);
-
-GdkGrabStatus
-gdk_fb_pointer_grab (GdkWindow * window,
- gint owner_events,
- GdkEventMask event_mask,
- GdkWindow * confine_to,
- GdkCursor * cursor,
- guint32 time,
- gboolean implicit_grab);
-void gdk_fb_pointer_ungrab (guint32 time, gboolean implicit_grab);
+void gdk_fb_drawing_context_init (GdkFBDrawingContext *dc,
+ GdkDrawable *drawable,
+ GdkGC *gc,
+ gboolean draw_bg,
+ gboolean do_clipping);
+void gdk_fb_drawing_context_finalize (GdkFBDrawingContext *dc);
+void gdk_fb_draw_drawable_3 (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPixmap *src,
+ GdkFBDrawingContext *dc,
+ gint xsrc,
+ gint ysrc,
+ gint xdest,
+ gint ydest,
+ gint width,
+ gint height);
+void gdk_fb_draw_drawable_2 (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPixmap *src,
+ gint xsrc,
+ gint ysrc,
+ gint xdest,
+ gint ydest,
+ gint width,
+ gint height,
+ gboolean draw_bg,
+ gboolean do_clipping);
+void gdk_fb_draw_rectangle (GdkDrawable *drawable,
+ GdkGC *gc,
+ gint filled,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+void gdk_fb_draw_lines (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPoint *points,
+ gint npoints);
+void gdk_fb_fill_spans (GdkDrawable *real_drawable,
+ GdkGC *gc,
+ GdkSpan *spans,
+ int nspans,
+ gboolean sorted);
+GdkRegion *gdk_fb_clip_region (GdkDrawable *drawable,
+ GdkGC *gc,
+ gboolean do_clipping,
+ gboolean do_children);
+
+
+GdkGrabStatus gdk_fb_pointer_grab (GdkWindow *window,
+ gint owner_events,
+ GdkEventMask event_mask,
+ GdkWindow *confine_to,
+ GdkCursor *cursor,
+ guint32 time,
+ gboolean implicit_grab);
+void gdk_fb_pointer_ungrab (guint32 time,
+ gboolean implicit_grab);
+
+guint32 gdk_fb_get_time (void);
+
extern GdkWindow *_gdk_fb_pointer_grab_window, *_gdk_fb_pointer_grab_window_events, *_gdk_fb_keyboard_grab_window, *_gdk_fb_pointer_grab_confine;
extern GdkEventMask _gdk_fb_pointer_grab_events, _gdk_fb_keyboard_grab_events;
--- /dev/null
+#include "gdkprivate-fb.h"
+#include <string.h>
+
+/*
+ * Reading pixel values from a generic drawable.
+ */
+
+static GetPixelRet
+gdk_fb_drawable_get_color (GdkDrawable *drawable,
+ GdkGC *gc,
+ int x,
+ int y,
+ GdkColor *spot)
+{
+ GetPixelRet retval = GPR_NONE;
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ guchar *mem = private->mem;
+ guint rowstride = private->rowstride;
+
+ switch (private->depth)
+ {
+ case 1:
+ {
+ guchar foo = mem[(x >> 3) + y * rowstride];
+ if (foo & (1 << (x % 8)))
+ *spot = GDK_GC_FBDATA (gc)->values.foreground;
+ else
+ {
+ retval = GPR_USED_BG;
+ *spot = GDK_GC_FBDATA (gc)->values.background;
+ }
+ }
+ break;
+ case 71:
+ if (mem[x + y * rowstride])
+ *spot = GDK_GC_FBDATA (gc)->values.foreground;
+ else
+ *spot = GDK_GC_FBDATA (gc)->values.background;
+ break;
+ case 77:
+ retval = GPR_AA_GRAYVAL;
+ spot->pixel = mem[x + y * rowstride] << 1;
+ spot->red = spot->green = spot->blue = spot->pixel << 8;
+ break;
+ case 78: /* AA mode */
+ retval = GPR_AA_GRAYVAL;
+ spot->pixel = mem[x + y * rowstride];
+ spot->red = spot->green = spot->blue = spot->pixel << 8;
+ break;
+ case 8:
+ spot->pixel = mem[x + y * rowstride];
+ *spot = private->colormap->colors[spot->pixel];
+ break;
+ case 16:
+ {
+ guint16 val16 = *((guint16 *)&mem[x*2 + y*rowstride]);
+
+ spot->red = (((1<<gdk_display->modeinfo.red.length) - 1) & (val16 >> gdk_display->modeinfo.red.offset)) << (16 - gdk_display->modeinfo.red.length);
+ spot->green = (((1<<gdk_display->modeinfo.green.length) - 1) & (val16 >> gdk_display->modeinfo.green.offset)) << (16 - gdk_display->modeinfo.green.length);
+ spot->blue = (((1<<gdk_display->modeinfo.blue.length) - 1) & (val16 >> gdk_display->modeinfo.blue.offset)) << (16 - gdk_display->modeinfo.blue.length);
+
+ spot->pixel = val16;
+ }
+ break;
+ case 24:
+ {
+ guchar *smem = &mem[x*3 + y*rowstride];
+ spot->red = smem[gdk_display->red_byte] << 8;
+ spot->green = smem[gdk_display->green_byte] << 8;
+ spot->blue = smem[gdk_display->blue_byte] << 8;
+#if (G_BYTE_ORDER == G_BIG_ENDIAN)
+ spot->pixel = (smem[0]<<16)|(smem[1]<<8)|smem[2];
+#else
+ spot->pixel = smem[0]|(smem[1]<<8)|(smem[2]<<16);
+#endif
+ }
+ break;
+ case 32:
+ {
+ guchar *smem = &mem[x*4 + y*rowstride];
+ spot->red = smem[gdk_display->red_byte] << 8;
+ spot->green = smem[gdk_display->green_byte] << 8;
+ spot->blue = smem[gdk_display->blue_byte] << 8;
+ spot->pixel = *(guint32 *)smem;
+ }
+ break;
+ }
+
+ return retval;
+}
+
+/*************************************
+ * gc->get_color() implementations
+ *************************************/
+
+static GetPixelRet
+gdk_fb_get_color_1 (GdkDrawable *drawable,
+ GdkGC *gc,
+ int x,
+ int y,
+ GdkColor *color)
+{
+ GetPixelRet retval = GPR_NONE;
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ guchar *mem = private->mem;
+ guint rowstride = private->rowstride;
+ guchar foo;
+
+ g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
+
+ foo = mem[(x >> 3) + y * rowstride];
+ if (foo & (1 << (x % 8)))
+ *color = GDK_GC_FBDATA (gc)->values.foreground;
+ else
+ {
+ retval = GPR_USED_BG;
+
+ *color = GDK_GC_FBDATA (gc)->values.background;
+ }
+
+ return retval;
+}
+
+static GetPixelRet
+gdk_fb_get_color_8 (GdkDrawable *drawable,
+ GdkGC *gc,
+ int x,
+ int y,
+ GdkColor *color)
+{
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ guchar *mem = private->mem;
+ guint rowstride = private->rowstride;
+ gint pixel;
+
+ g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
+
+ pixel = mem[x + y * rowstride];
+ *color = private->colormap->colors[pixel];
+
+ return GPR_NONE;
+}
+
+static GetPixelRet
+gdk_fb_get_color_16 (GdkDrawable *drawable,
+ GdkGC *gc,
+ int x,
+ int y,
+ GdkColor *color)
+{
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ guchar *mem = private->mem;
+ guint rowstride = private->rowstride;
+ guint16 val16;
+
+ g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
+
+ val16 = *((guint16 *)&mem[x*2 + y*rowstride]);
+
+ color->red = (((1<<gdk_display->modeinfo.red.length) - 1) & (val16 >> gdk_display->modeinfo.red.offset)) << (16 - gdk_display->modeinfo.red.length);
+ color->green = (((1<<gdk_display->modeinfo.green.length) - 1) & (val16 >> gdk_display->modeinfo.green.offset)) << (16 - gdk_display->modeinfo.green.length);
+ color->blue = (((1<<gdk_display->modeinfo.blue.length) - 1) & (val16 >> gdk_display->modeinfo.blue.offset)) << (16 - gdk_display->modeinfo.blue.length);
+
+ color->pixel = val16;
+
+ return GPR_NONE;
+}
+
+static GetPixelRet
+gdk_fb_get_color_24 (GdkDrawable *drawable,
+ GdkGC *gc,
+ int x,
+ int y,
+ GdkColor *color)
+{
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ guchar *mem = private->mem;
+ guint rowstride = private->rowstride;
+ guchar *smem;
+
+ g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
+
+ smem = &mem[x*3 + y*rowstride];
+ color->red = smem[gdk_display->red_byte] << 8;
+ color->green = smem[gdk_display->green_byte] << 8;
+ color->blue = smem[gdk_display->blue_byte] << 8;
+#if (G_BYTE_ORDER == G_BIG_ENDIAN)
+ color->pixel = (smem[0]<<16)|(smem[1]<<8)|smem[2];
+#else
+ color->pixel = smem[0]|(smem[1]<<8)|(smem[2]<<16);
+#endif
+
+ return GPR_NONE;
+}
+
+static GetPixelRet
+gdk_fb_get_color_32 (GdkDrawable *drawable,
+ GdkGC *gc,
+ int x,
+ int y,
+ GdkColor *color)
+{
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ guchar *mem = private->mem;
+ guint rowstride = private->rowstride;
+ guchar *smem;
+
+ g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
+
+ smem = &mem[x*4 + y*rowstride];
+ color->red = smem[gdk_display->red_byte] << 8;
+ color->green = smem[gdk_display->green_byte] << 8;
+ color->blue = smem[gdk_display->blue_byte] << 8;
+ color->pixel = *(guint32 *)smem;
+
+ return GPR_NONE;
+}
+
+/*************************************
+ * gc->set_pixel() implementations
+ *************************************/
+
+static void
+gdk_fb_set_pixel_1(GdkDrawable *drawable,
+ GdkGC *gc,
+ int x,
+ int y,
+ gulong pixel)
+{
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ guchar *mem = private->mem;
+ guint rowstride = private->rowstride;
+ guchar *ptr;
+
+ g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
+
+ ptr = mem + (y*rowstride) + (x >> 3);
+
+ if (pixel)
+ *ptr |= (1 << (x % 8));
+ else
+ *ptr &= ~(1 << (x % 8));
+}
+
+static void
+gdk_fb_set_pixel_8(GdkDrawable *drawable,
+ GdkGC *gc,
+ int x,
+ int y,
+ gulong pixel)
+{
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ guchar *mem = private->mem;
+ guint rowstride = private->rowstride;
+
+ g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
+
+ mem[x + y*rowstride] = pixel;
+}
+
+static void
+gdk_fb_set_pixel_16(GdkDrawable *drawable,
+ GdkGC *gc,
+ int x,
+ int y,
+ gulong pixel)
+{
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ guchar *mem = private->mem;
+ guint rowstride = private->rowstride;
+ guint16 *ptr;
+
+ g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
+
+ ptr = (guint16 *)&mem[x*2 + y*rowstride];
+ *ptr = pixel;
+}
+
+static void
+gdk_fb_set_pixel_24(GdkDrawable *drawable,
+ GdkGC *gc,
+ int x,
+ int y,
+ gulong pixel)
+{
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ guchar *mem = private->mem;
+ guint rowstride = private->rowstride;
+ guchar *smem;
+
+ g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
+
+ smem = &mem[x*3 + y*rowstride];
+ smem[0] = pixel & 0xff;
+ smem[1] = (pixel >> 8) & 0xff;
+ smem[2] = (pixel >> 16) & 0xff;
+}
+
+static void
+gdk_fb_set_pixel_32(GdkDrawable *drawable,
+ GdkGC *gc,
+ int x,
+ int y,
+ gulong pixel)
+{
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ guchar *mem = private->mem;
+ guint rowstride = private->rowstride;
+ guint32 *smem;
+
+ g_assert (private->depth == GDK_GC_FBDATA (gc)->depth);
+
+ smem = (guint32 *)&mem[x*4 + y*rowstride];
+ *smem = pixel;
+}
+
+
+/*************************************
+ * gc->fill_span() implementations
+ *************************************/
+
+static void
+gdk_fb_fill_span_generic (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkSpan *span,
+ GdkColor *color)
+{
+ int curx;
+ GdkColor spot = *color;
+ GdkGCFBData *gc_private;
+ GdkDrawableFBData *private;
+ gint left, right, y;
+ int clipxoff, clipyoff; /* Amounts to add to curx & cury to get x & y in clip mask */
+ int tsxoff, tsyoff;
+ GdkDrawable *cmask;
+ guchar *clipmem;
+ guint mask_rowstride;
+ GdkPixmap *ts = NULL;
+ GdkDrawableFBData *ts_private;
+ gboolean solid_stipple;
+ GdkFunction func;
+
+ private = GDK_DRAWABLE_FBDATA (drawable);
+ gc_private = GDK_GC_FBDATA (gc);
+
+ g_assert (gc);
+
+ y = span->y;
+ left = span->x;
+ right = span->x + span->width;
+
+ func = gc_private->values.function;
+
+ cmask = gc_private->values.clip_mask;
+ clipxoff = clipyoff = tsxoff = tsyoff = 0;
+ mask_rowstride = 0;
+ solid_stipple = FALSE;
+ clipmem = NULL;
+
+ if (cmask)
+ {
+ GdkDrawableFBData *cmask_private;
+
+ cmask_private = GDK_DRAWABLE_IMPL_FBDATA (cmask);
+
+ clipmem = cmask_private->mem;
+ clipxoff = cmask_private->abs_x - gc_private->values.clip_x_origin - private->abs_x;
+ clipyoff = cmask_private->abs_y - gc_private->values.clip_y_origin - private->abs_y;
+ mask_rowstride = cmask_private->rowstride;
+ }
+
+ if (gc_private->values.fill == GDK_TILED &&
+ gc_private->values.tile)
+ {
+ gint xstep;
+ gint relx, rely;
+ int drawh;
+ GdkFBDrawingContext *dc, dc_data;
+
+ dc = &dc_data;
+
+ gdk_fb_drawing_context_init (dc, drawable, gc, FALSE, TRUE);
+
+ ts = gc_private->values.tile;
+ ts_private = GDK_DRAWABLE_IMPL_FBDATA (ts);
+
+ rely = y - private->abs_y;
+ drawh = (rely + gc_private->values.ts_y_origin) % ts_private->height;
+ if (drawh < 0)
+ drawh += GDK_DRAWABLE_FBDATA (ts)->height;
+
+ for (curx = left; curx < right; curx += xstep)
+ {
+ int draww;
+
+ relx = curx - private->abs_x;
+
+ draww = (relx + gc_private->values.ts_x_origin) % ts_private->width;
+ if (draww < 0)
+ draww += ts_private->width;
+
+ xstep = MIN (ts_private->width - draww, right - relx);
+
+ gdk_fb_draw_drawable_3 (drawable, gc, GDK_DRAWABLE_IMPL (ts),
+ dc,
+ draww, drawh,
+ relx, rely,
+ xstep, 1);
+ }
+
+ gdk_fb_drawing_context_finalize (dc);
+
+ return;
+ }
+ else if ((gc_private->values.fill == GDK_STIPPLED ||
+ gc_private->values.fill == GDK_OPAQUE_STIPPLED) &&
+ gc_private->values.stipple)
+ {
+ ts = gc_private->values.stipple;
+ tsxoff = GDK_DRAWABLE_FBDATA (ts)->abs_x - gc_private->values.ts_x_origin - private->abs_x;
+ tsyoff = GDK_DRAWABLE_FBDATA (ts)->abs_y - gc_private->values.ts_y_origin - private->abs_y;
+ solid_stipple = (gc_private->values.fill == GDK_OPAQUE_STIPPLED);
+ }
+
+ for (curx = left; curx < right; curx++)
+ {
+ int maskx = curx+clipxoff, masky = y + clipyoff;
+ guchar foo;
+
+ if (cmask)
+ {
+ foo = clipmem[masky*mask_rowstride + (maskx >> 3)];
+
+ if (!(foo & (1 << (maskx % 8))))
+ continue;
+ }
+
+ if (func == GDK_INVERT)
+ {
+ (gc_private->get_color) (drawable, gc, curx, y, &spot);
+ spot.pixel = ~spot.pixel;
+ spot.red = ~spot.red;
+ spot.green = ~spot.green;
+ spot.blue = ~spot.blue;
+ }
+ else if (ts)
+ {
+ int wid, hih;
+
+ ts_private = GDK_DRAWABLE_IMPL_FBDATA (ts);
+
+ wid = ts_private->width;
+ hih = ts_private->height;
+
+ maskx = (curx+tsxoff)%wid;
+ masky = (y+tsyoff)%hih;
+ if (maskx < 0)
+ maskx += wid;
+ if (masky < 0)
+ masky += hih;
+
+ foo = ts_private->mem[(maskx >> 3) + ts_private->rowstride*masky];
+ if (foo & (1 << (maskx % 8)))
+ {
+ spot = gc_private->values.foreground;
+ }
+ else if (solid_stipple)
+ {
+ spot = gc_private->values.background;
+ }
+ else
+ continue;
+ }
+
+ (gc_private->set_pixel) (drawable, gc, curx, y, spot.pixel);
+ }
+}
+
+static void
+gdk_fb_fill_span_simple_1 (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkSpan *span,
+ GdkColor *color)
+{
+ int curx;
+ GdkGCFBData *gc_private;
+ GdkDrawableFBData *private;
+ guchar *mem, *ptr;
+ guint rowstride;
+ gint left, right, y;
+
+ private = GDK_DRAWABLE_FBDATA (drawable);
+ gc_private = GDK_GC_FBDATA (gc);
+
+ g_assert (gc);
+
+ g_assert (!gc_private->values.clip_mask &&
+ !gc_private->values.tile &&
+ !gc_private->values.stipple &&
+ gc_private->values.function != GDK_INVERT);
+
+ y = span->y;
+ left = span->x;
+ right = span->x + span->width;
+
+ mem = private->mem;
+ rowstride = private->rowstride;
+
+ {
+ int fromx = MIN ((left+7)&(~7), right);
+ int begn = fromx - left, begoff = left % 8, endn;
+ guchar begmask, endmask;
+ int body_end = right & ~7;
+ int body_len = (body_end - fromx)/8;
+
+ begmask = ((1 << (begn + begoff)) - 1)
+ & ~((1 << (begoff)) - 1);
+ endn = right - body_end;
+ endmask = (1 << endn) - 1;
+
+ ptr = mem + y*rowstride + (left >> 3);
+
+ if (color->pixel)
+ *ptr |= begmask;
+ else
+ *ptr &= ~begmask;
+
+ curx = fromx;
+
+ if (curx < right)
+ {
+ ptr = mem + y*rowstride + (curx >> 3);
+ memset (ptr, color->pixel?0xFF:0, body_len);
+
+ if (endn)
+ {
+ ptr = mem + y*rowstride + (body_end >> 3);
+ if (color->pixel)
+ *ptr |= endmask;
+ else
+ *ptr &= ~endmask;
+ }
+ }
+ }
+}
+
+static void
+gdk_fb_fill_span_simple_8 (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkSpan *span,
+ GdkColor *color)
+{
+ GdkGCFBData *gc_private;
+ GdkDrawableFBData *private;
+ guchar *mem, *ptr;
+ guint rowstride;
+
+ private = GDK_DRAWABLE_FBDATA (drawable);
+ gc_private = GDK_GC_FBDATA (gc);
+
+ g_assert (gc);
+
+ g_assert (!gc_private->values.clip_mask &&
+ !gc_private->values.tile &&
+ !gc_private->values.stipple &&
+ gc_private->values.function != GDK_INVERT);
+
+ mem = private->mem;
+ rowstride = private->rowstride;
+
+ ptr = mem + span->y*rowstride + span->x;
+ memset (ptr, color->pixel, span->width);
+}
+static void
+gdk_fb_fill_span_simple_16 (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkSpan *span,
+ GdkColor *color)
+{
+ GdkGCFBData *gc_private;
+ GdkDrawableFBData *private;
+ guchar *mem;
+ guint rowstride;
+ guint16 *p16;
+ int n;
+ int i;
+
+ private = GDK_DRAWABLE_FBDATA (drawable);
+ gc_private = GDK_GC_FBDATA (gc);
+
+ g_assert (gc);
+
+ g_assert (!gc_private->values.clip_mask &&
+ !gc_private->values.tile &&
+ !gc_private->values.stipple &&
+ gc_private->values.function != GDK_INVERT);
+
+ mem = private->mem;
+ rowstride = private->rowstride;
+
+ n = span->width;
+ p16 = (guint16 *)(mem + span->y * rowstride + span->x*2);
+ for (i = 0; i < n; i++)
+ *(p16++) = color->pixel;
+}
+
+static void
+gdk_fb_fill_span_simple_24 (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkSpan *span,
+ GdkColor *color)
+{
+ GdkGCFBData *gc_private;
+ GdkDrawableFBData *private;
+ guchar *mem, *ptr;
+ guint rowstride;
+ int n;
+ guchar redval, greenval, blueval;
+ guchar *firstline, *ptr_end;
+
+ private = GDK_DRAWABLE_FBDATA (drawable);
+ gc_private = GDK_GC_FBDATA (gc);
+
+ g_assert (gc);
+
+ g_assert (!gc_private->values.clip_mask &&
+ !gc_private->values.tile &&
+ !gc_private->values.stipple &&
+ gc_private->values.function != GDK_INVERT);
+
+ mem = private->mem;
+ rowstride = private->rowstride;
+
+ redval = color->red>>8;
+ greenval = color->green>>8;
+ blueval = color->blue>>8;
+
+ n = span->width*3;
+
+ firstline = ptr = mem + span->y * rowstride + span->x*3;
+ ptr_end = ptr+n;
+ while (ptr < ptr_end)
+ {
+ ptr[gdk_display->red_byte] = redval;
+ ptr[gdk_display->green_byte] = greenval;
+ ptr[gdk_display->blue_byte] = blueval;
+ ptr += 3;
+ }
+}
+static void
+gdk_fb_fill_span_simple_32 (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkSpan *span,
+ GdkColor *color)
+{
+ GdkGCFBData *gc_private;
+ GdkDrawableFBData *private;
+ guchar *mem;
+ guint rowstride;
+ guint32 *p32;
+ int n;
+ int i;
+
+ private = GDK_DRAWABLE_FBDATA (drawable);
+ gc_private = GDK_GC_FBDATA (gc);
+
+ g_assert (gc);
+
+ g_assert (!gc_private->values.clip_mask &&
+ !gc_private->values.tile &&
+ !gc_private->values.stipple &&
+ gc_private->values.function != GDK_INVERT);
+
+ mem = private->mem;
+ rowstride = private->rowstride;
+
+ n = span->width;
+ p32 = (guint32 *)(mem + span->y * rowstride + span->x*4);
+ for (i = 0; i < n; i++)
+ *(p32++) = color->pixel;
+}
+
+
+/*************************************
+ * gc->draw_drawable() implementations
+ *************************************/
+
+static void
+gdk_fb_draw_drawable_generic (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPixmap *src,
+ GdkFBDrawingContext *dc,
+ gint start_y,
+ gint end_y,
+ gint start_x,
+ gint end_x,
+ gint src_x_off,
+ gint src_y_off,
+ gint draw_direction)
+{
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ int cur_x, cur_y;
+
+ for (cur_y = start_y; cur_y*draw_direction < end_y*draw_direction; cur_y+=draw_direction)
+ {
+ for (cur_x = start_x; cur_x < end_x; cur_x++)
+ {
+ GdkColor spot;
+
+ if (GDK_GC_FBDATA(gc)->values.clip_mask)
+ {
+ int maskx = cur_x + dc->clipxoff, masky = cur_y + dc->clipyoff;
+ guchar foo;
+
+ foo = dc->clipmem[masky*dc->clip_rowstride + (maskx >> 3)];
+
+ if (!(foo & (1 << (maskx % 8))))
+ continue;
+ }
+
+ switch (gdk_fb_drawable_get_color (src, gc, cur_x + src_x_off, cur_y + src_y_off, &spot))
+ {
+ case GPR_AA_GRAYVAL:
+ {
+ GdkColor realspot, fg;
+ guint graylevel = spot.pixel;
+ gint tmp;
+
+ if (private->depth == 1)
+ {
+ if (spot.pixel > 192)
+ spot = GDK_GC_FBDATA (gc)->values.foreground;
+ else
+ spot = GDK_GC_FBDATA (gc)->values.background;
+ break;
+ }
+ else
+ {
+ if (graylevel >= 254)
+ {
+ spot = GDK_GC_FBDATA (gc)->values.foreground;
+ }
+ else if (graylevel <= 2)
+ {
+ if (!dc->draw_bg)
+ continue;
+
+ spot = GDK_GC_FBDATA (gc)->values.background;
+ }
+ else
+ {
+ switch ((GDK_GC_FBDATA (gc)->get_color) (drawable, gc, cur_x, cur_y, &realspot))
+ {
+ case GPR_USED_BG:
+ {
+ int bgx, bgy;
+
+ bgx = (cur_x - GDK_DRAWABLE_IMPL_FBDATA (dc->bg_relto)->abs_x) % GDK_DRAWABLE_IMPL_FBDATA (dc->bgpm)->width + private->abs_x;
+ bgy = (cur_y - GDK_DRAWABLE_IMPL_FBDATA (dc->bg_relto)->abs_y) % GDK_DRAWABLE_IMPL_FBDATA (dc->bgpm)->height + private->abs_y;
+ gdk_fb_drawable_get_color (dc->bgpm, gc, bgx, bgy, &realspot);
+ }
+ break;
+ case GPR_NONE:
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ fg = GDK_GC_FBDATA (gc)->values.foreground;
+
+ /* Now figure out what 'spot' should actually look like */
+ fg.red >>= 8;
+ fg.green >>= 8;
+ fg.blue >>= 8;
+ realspot.red >>= 8;
+ realspot.green >>= 8;
+ realspot.blue >>= 8;
+
+
+ tmp = (fg.red - realspot.red) * graylevel;
+ spot.red = realspot.red + ((tmp + (tmp >> 8) + 0x80) >> 8);
+ spot.red <<= 8;
+
+ tmp = (fg.green - realspot.green) * graylevel;
+ spot.green = realspot.green + ((tmp + (tmp >> 8) + 0x80) >> 8);
+ spot.green <<= 8;
+
+ tmp = (fg.blue - realspot.blue) * graylevel;
+ spot.blue = realspot.blue + ((tmp + (tmp >> 8) + 0x80) >> 8);
+ spot.blue <<= 8;
+
+ /* Now find the pixel for this thingie */
+ switch (private->depth)
+ {
+ case 8:
+ if (!gdk_colormap_alloc_color (private->colormap, &spot, FALSE, TRUE))
+ {
+ g_error ("Can't allocate AA color!");
+ }
+ break;
+ case 16:
+ spot.pixel = (spot.red >> (16 - gdk_display->modeinfo.red.length)) << gdk_display->modeinfo.red.offset;
+ spot.pixel |= (spot.green >> (16 - gdk_display->modeinfo.green.length)) << gdk_display->modeinfo.green.offset;
+ spot.pixel |= (spot.blue >> (16 - gdk_display->modeinfo.blue.length)) << gdk_display->modeinfo.blue.offset;
+ break;
+ case 24:
+ case 32:
+ spot.pixel = ((spot.red & 0xFF00) >> 8 << (gdk_display->modeinfo.red.offset))
+ | ((spot.green & 0xFF00) >> 8 << (gdk_display->modeinfo.green.offset))
+ | ((spot.blue & 0xFF00) >> 8 << (gdk_display->modeinfo.blue.offset));
+ break;
+ }
+ }
+ }
+ }
+ break;
+ case GPR_USED_BG:
+ if (!dc->draw_bg)
+ continue;
+ break;
+ case GPR_NONE:
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ (GDK_GC_FBDATA (gc)->set_pixel) (drawable, gc, cur_x, cur_y, spot.pixel);
+ }
+ }
+
+}
+
+void
+gdk_fb_draw_drawable_memmove (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPixmap *src,
+ GdkFBDrawingContext *dc,
+ gint start_y,
+ gint end_y,
+ gint start_x,
+ gint end_x,
+ gint src_x_off,
+ gint src_y_off,
+ gint draw_direction)
+{
+ GdkDrawableFBData *src_private = GDK_DRAWABLE_FBDATA (src);
+ guint depth = src_private->depth;
+ guint src_rowstride = src_private->rowstride;
+ guchar *srcmem = src_private->mem;
+ int linelen = (end_x - start_x)*(depth>>3);
+ gint cur_y;
+
+ for(cur_y = start_y; cur_y*draw_direction < end_y*draw_direction; cur_y += draw_direction)
+ {
+ memmove (dc->mem + (cur_y * dc->rowstride) + start_x*(depth>>3),
+ srcmem + ((cur_y + src_y_off)*src_rowstride) + (start_x + src_x_off)*(depth>>3),
+ linelen);
+ }
+
+}
+
+static void
+gdk_fb_draw_drawable_aa_24 (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPixmap *src,
+ GdkFBDrawingContext *dc,
+ gint start_y,
+ gint end_y,
+ gint start_x,
+ gint end_x,
+ gint src_x_off,
+ gint src_y_off,
+ gint draw_direction)
+{
+ GdkDrawableFBData *private = GDK_DRAWABLE_FBDATA (drawable);
+ int x, y;
+ GdkGCFBData *gc_private;
+ guchar *dmem = private->mem;
+ guint dst_rowstride = private->rowstride;
+ guchar *smem = GDK_DRAWABLE_FBDATA (src)->mem;
+ guint src_rowstride = GDK_DRAWABLE_FBDATA (src)->rowstride;
+ guchar *dst;
+ guint grayval;
+ gint r, g, b, tmp;
+ GdkColor fg;
+ gint fg_r, fg_g, fg_b;
+
+ gc_private = GDK_GC_FBDATA (gc);
+
+ fg = GDK_GC_FBDATA (gc)->values.foreground;
+ fg_r = fg.red >> 8;
+ fg_g = fg.green >> 8;
+ fg_b = fg.blue >> 8;
+
+ for (y = start_y; y*draw_direction < end_y*draw_direction; y+=draw_direction)
+ {
+ for (x = start_x; x < end_x; x++)
+ {
+ grayval = smem[x + src_x_off + (y + src_y_off) * src_rowstride];
+
+ if ((grayval <= 2) && (!dc->draw_bg))
+ continue;
+
+ dst = &dmem[x*3 + y*dst_rowstride];
+
+ if (grayval >= 254)
+ {
+ dst[gdk_display->red_byte] = fg_r;
+ dst[gdk_display->green_byte] = fg_g;
+ dst[gdk_display->blue_byte] = fg_b;
+ }
+ else if (grayval <= 2)
+ {
+ dst[gdk_display->red_byte] = GDK_GC_FBDATA (gc)->values.background.red >> 8;
+ dst[gdk_display->green_byte] = GDK_GC_FBDATA (gc)->values.background.green >> 8;
+ dst[gdk_display->blue_byte] = GDK_GC_FBDATA (gc)->values.background.blue >> 8;
+ }
+ else
+ {
+ r = dst[gdk_display->red_byte];
+ tmp = (fg_r - r) * (gint)grayval;
+ r = r + ((tmp + (tmp >> 8) + 0x80) >> 8);
+ dst[gdk_display->red_byte] = r;
+
+ g = dst[gdk_display->green_byte];
+ tmp = (fg_g - g) * (gint)grayval;
+ g = g + ((tmp + (tmp >> 8) + 0x80) >> 8);
+ dst[gdk_display->green_byte] = g;
+
+ b = dst[gdk_display->blue_byte];
+ tmp = (fg_b - b) * (gint)grayval;
+ b = b + ((tmp + (tmp >> 8) + 0x80) >> 8);
+ dst[gdk_display->blue_byte] = b;
+ }
+ }
+ }
+}
+
+/*************************************
+ * gc->fill_rectangle() implementations
+ *************************************/
+
+void
+gdk_fb_fill_rectangle_generic (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkRectangle *rect,
+ GdkColor *color)
+{
+ GdkDrawableFBData *private;
+ GdkSpan *spans;
+ int i;
+
+ private = GDK_DRAWABLE_FBDATA (drawable);
+
+ spans = g_new (GdkSpan, rect->height);
+ for (i=0;i<rect->height;i++)
+ {
+ spans[i].x = rect->x - private->abs_x;
+ spans[i].y = rect->y+i - private->abs_y;
+ spans[i].width = rect->width;
+ }
+ gdk_fb_fill_spans (drawable, gc, spans, rect->height, TRUE);
+ g_free (spans);
+}
+
+void
+gdk_fb_fill_rectangle_simple_16 (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkRectangle *rect,
+ GdkColor *color)
+{
+ GdkGCFBData *gc_private;
+ GdkDrawableFBData *private;
+ guchar *ptr;
+ guint rowstride;
+ int n;
+ gboolean extra;
+ int i;
+ guint32 pixel;
+ gint height;
+
+ private = GDK_DRAWABLE_FBDATA (drawable);
+ gc_private = GDK_GC_FBDATA (gc);
+
+ rowstride = private->rowstride - rect->width*2;
+ ptr = (guchar *)private->mem + rect->y * private->rowstride + rect->x*2;
+
+ extra = rect->width&1;
+ n = rect->width>>1;
+
+ pixel = (color->pixel << 16) | color->pixel;
+
+ height = rect->height;
+ while (height>0)
+ {
+ i = n;
+ while (i>0)
+ {
+ *(guint32 *)ptr = pixel;
+ ptr += 4;
+ i--;
+ }
+ if (extra)
+ {
+ *(guint16 *)ptr = color->pixel;
+ ptr += 2;
+ }
+ ptr += rowstride;
+ height--;
+ }
+}
+
+void
+gdk_fb_fill_rectangle_simple_32 (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkRectangle *rect,
+ GdkColor *color)
+{
+ GdkGCFBData *gc_private;
+ GdkDrawableFBData *private;
+ guchar *ptr;
+ guint rowstride;
+ int n;
+ int i;
+ guint32 pixel;
+ gint height;
+
+ private = GDK_DRAWABLE_FBDATA (drawable);
+ gc_private = GDK_GC_FBDATA (gc);
+
+ rowstride = private->rowstride - rect->width*4;
+ ptr = (guchar *)private->mem + rect->y * private->rowstride + rect->x*4;
+
+ n = rect->width;
+
+ pixel = color->pixel;
+
+ height = rect->height;
+ while (height>0)
+ {
+ i = n;
+ while (i>0)
+ {
+ *(guint32 *)ptr = pixel;
+ ptr += 4;
+ i--;
+ }
+ ptr += rowstride;
+ height--;
+ }
+}
+
+
+/*************************************
+ * GC state calculation
+ *************************************/
+
+void
+_gdk_fb_gc_calc_state (GdkGC *gc,
+ GdkGCValuesMask changed)
+{
+ GdkGCFBData *gc_private;
+ int i;
+
+ gc_private = GDK_GC_FBDATA (gc);
+
+ gc_private->fill_span = gdk_fb_fill_span_generic;
+ gc_private->fill_rectangle = gdk_fb_fill_rectangle_generic;
+
+ for (i=0;i<GDK_NUM_FB_SRCBPP;i++)
+ gc_private->draw_drawable[i] = gdk_fb_draw_drawable_generic;
+
+ if (changed & _GDK_FB_GC_DEPTH)
+ switch (gc_private->depth)
+ {
+ case 1:
+ gc_private->set_pixel = gdk_fb_set_pixel_1;
+ gc_private->get_color = gdk_fb_get_color_1;
+ break;
+ case 8:
+ gc_private->set_pixel = gdk_fb_set_pixel_8;
+ gc_private->get_color = gdk_fb_get_color_8;
+ break;
+ case 16:
+ gc_private->set_pixel = gdk_fb_set_pixel_16;
+ gc_private->get_color = gdk_fb_get_color_16;
+ break;
+ case 24:
+ gc_private->set_pixel = gdk_fb_set_pixel_24;
+ gc_private->get_color = gdk_fb_get_color_24;
+ break;
+ case 32:
+ gc_private->set_pixel = gdk_fb_set_pixel_32;
+ gc_private->get_color = gdk_fb_get_color_32;
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ if (!gc_private->values.clip_mask)
+ {
+ switch (gc_private->depth)
+ {
+ case 8:
+ gc_private->draw_drawable[GDK_FB_SRC_BPP_8] = gdk_fb_draw_drawable_memmove;
+ break;
+ case 16:
+ gc_private->draw_drawable[GDK_FB_SRC_BPP_16] = gdk_fb_draw_drawable_memmove;
+ break;
+ case 24:
+ gc_private->draw_drawable[GDK_FB_SRC_BPP_8_AA_GRAYVAL] = gdk_fb_draw_drawable_aa_24;
+ gc_private->draw_drawable[GDK_FB_SRC_BPP_24] = gdk_fb_draw_drawable_memmove;
+ break;
+ case 32:
+ gc_private->draw_drawable[GDK_FB_SRC_BPP_32] = gdk_fb_draw_drawable_memmove;
+ break;
+ }
+ }
+
+ if (!gc_private->values.clip_mask &&
+ !gc_private->values.tile &&
+ !gc_private->values.stipple &&
+ gc_private->values.function != GDK_INVERT)
+ {
+ switch (gc_private->depth)
+ {
+ case 1:
+ gc_private->fill_span = gdk_fb_fill_span_simple_1;
+ break;
+ case 8:
+ gc_private->fill_span = gdk_fb_fill_span_simple_8;
+ break;
+ case 16:
+ gc_private->fill_span = gdk_fb_fill_span_simple_16;
+ gc_private->fill_rectangle = gdk_fb_fill_rectangle_simple_16;
+ break;
+ case 24:
+ gc_private->fill_span = gdk_fb_fill_span_simple_24;
+ break;
+ case 32:
+ gc_private->fill_span = gdk_fb_fill_span_simple_32;
+ gc_private->fill_rectangle = gdk_fb_fill_rectangle_simple_32;
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+ }
+
+}
+
static void
miFillWideEllipse(GdkDrawable *pDraw, GdkGC *pGC, miArc *parc)
{
- GdkRectangle* points;
- register GdkRectangle* pts;
+ GdkSpan* points;
+ register GdkSpan* pts;
miArcSpanData *spdata;
gboolean mustFree;
register miArcSpan *span;
register int n;
yorgu = parc->height + GDK_GC_FBDATA(pGC)->values.line_width;
- points = ALLOCATE_LOCAL(sizeof(GdkRectangle) * yorgu * 2);
+ points = ALLOCATE_LOCAL(sizeof(GdkSpan) * yorgu * 2);
spdata = miComputeWideEllipse(GDK_GC_FBDATA(pGC)->values.line_width, parc, &mustFree);
if (!spdata)
{
{
pts->x = xorg;
pts->y = yorgu - 1;
- pts->width = pts->height = 1;
+ pts->width = 1;
pts++;
span++;
}
{
pts[0].x = xorg + span->lx;
pts[0].y = yorgu;
- pts[0].height = 1;
pts[0].width = span->lw;
pts[1] = pts[0];
pts[1].y = yorgl;
{
pts[0].x = xorg;
pts[0].y = yorgl;
- pts[0].width = pts[0].height = 1;
+ pts[0].width = 1;
pts++;
}
for (n = spdata->count2; --n >= 0; )
pts[0].x = xorg + span->lx;
pts[0].y = yorgu;
pts[0].width = span->lw;
- pts[0].height = 1;
pts[1].x = xorg + span->rx;
pts[1].y = pts[0].y;
pts[1].width = span->rw;
- pts[1].height = 1;
pts[2].x = pts[0].x;
pts[2].y = yorgl;
- pts[2].height = 1;
pts[2].width = pts[0].width;
pts[3].x = pts[1].x;
pts[3].y = pts[2].y;
pts[3].width = pts[1].width;
- pts[3].height = 1;
yorgu++;
yorgl--;
pts[0].x = xorg + span->lx;
pts[0].y = yorgu;
pts[0].width = span->lw;
- pts[0].height = 1;
pts++;
}
else
pts[0].x = xorg + span->lx;
pts[0].y = yorgu;
pts[0].width = span->lw;
- pts[0].height = 1;
pts[1].x = xorg + span->rx;
pts[1].y = pts[0].y;
pts[1].width = span->rw;
- pts[1].height = 1;
pts += 2;
}
}
if (mustFree)
g_free(spdata);
- gdk_fb_fill_spans(pDraw, pGC, points, pts - points);
+ gdk_fb_fill_spans(pDraw, pGC, points, pts - points, FALSE);
DEALLOCATE_LOCAL(points);
}
GdkGC* pGC;
{
register struct finalSpan *span;
- register GdkRectangle* xSpan;
+ register GdkSpan* xSpan;
register int i;
register struct finalSpan **f;
register int spany;
- GdkRectangle* xSpans;
+ GdkSpan* xSpans;
if (nspans == 0)
return;
- xSpan = xSpans = (GdkRectangle*) ALLOCATE_LOCAL (nspans * sizeof (GdkRectangle));
+ xSpan = xSpans = (GdkSpan*) ALLOCATE_LOCAL (nspans * sizeof (GdkSpan));
if (xSpans)
{
i = 0;
xSpan->x = span->min;
xSpan->y = spany;
xSpan->width = span->max - span->min;
- xSpan->height = 1;
++xSpan;
++i;
}
}
- gdk_fb_fill_spans(pDrawable, pGC, xSpans, i);
+ gdk_fb_fill_spans(pDrawable, pGC, xSpans, i, TRUE);
}
disposeFinalSpans ();
if (xSpans)
pts->x = xorg - x; \
pts->y = yorg - y; \
pts->width = slw; \
- pts->height = 1; \
pts++; \
if (miFillArcLower(slw)) \
{ \
pts->x = xorg - x; \
pts->y = yorg + y + dy; \
pts->width = slw; \
- pts->height = 1; \
pts++; \
}
int yk, xk, ym, xm, dx, dy, xorg, yorg;
int slw;
miFillArcRec info;
- GdkRectangle* points;
- register GdkRectangle* pts;
+ GdkSpan* points;
+ register GdkSpan* pts;
- points = (GdkRectangle*)ALLOCATE_LOCAL(sizeof(GdkRectangle) * arc->height);
+ points = (GdkSpan*)ALLOCATE_LOCAL(sizeof(GdkSpan) * arc->height);
if (!points)
return;
miFillArcSetup(arc, &info);
MIFILLARCSTEP(slw);
ADDSPANS();
}
- gdk_fb_fill_spans(pDraw, pGC, points, pts - points);
+ gdk_fb_fill_spans(pDraw, pGC, points, pts - points, FALSE);
DEALLOCATE_LOCAL(points);
}
int xorg, yorg, dx, dy, slw;
double e, yk, xk, ym, xm;
miFillArcDRec info;
- GdkRectangle* points;
- register GdkRectangle* pts;
+ GdkSpan* points;
+ register GdkSpan* pts;
- points = (GdkRectangle*)ALLOCATE_LOCAL(sizeof(GdkRectangle) * arc->height);
+ points = (GdkSpan*)ALLOCATE_LOCAL(sizeof(GdkSpan) * arc->height);
if (!points)
return;
miFillArcDSetup(arc, &info);
MIFILLARCSTEP(slw);
ADDSPANS();
}
- gdk_fb_fill_spans(pDraw, pGC, points, pts - points);
+ gdk_fb_fill_spans(pDraw, pGC, points, pts - points, FALSE);
DEALLOCATE_LOCAL(points);
}
pts->x = l; \
pts->y = ya; \
pts->width = r - l + 1; \
- pts->height = 1; \
pts++; \
}
miFillArcRec info;
miArcSliceRec slice;
int ya, xl, xr, xc;
- GdkRectangle* points;
- register GdkRectangle* pts;
+ GdkSpan* points;
+ register GdkSpan* pts;
miFillArcSetup(arc, &info);
miFillArcSliceSetup(arc, &slice, pGC);
slw = arc->height;
if (slice.flip_top || slice.flip_bot)
slw += (arc->height >> 1) + 1;
- points = (GdkRectangle*)ALLOCATE_LOCAL(sizeof(GdkRectangle) * slw);
+ points = (GdkSpan*)ALLOCATE_LOCAL(sizeof(GdkSpan) * slw);
if (!points)
return;
pts = points;
}
}
- gdk_fb_fill_spans(pDraw, pGC, points, pts - points);
+ gdk_fb_fill_spans(pDraw, pGC, points, pts - points, FALSE);
DEALLOCATE_LOCAL(points);
}
miFillArcDRec info;
miArcSliceRec slice;
int ya, xl, xr, xc;
- GdkRectangle* points;
- register GdkRectangle* pts;
+ GdkSpan* points;
+ register GdkSpan* pts;
miFillArcDSetup(arc, &info);
miFillArcSliceSetup(arc, &slice, pGC);
slw = arc->height;
if (slice.flip_top || slice.flip_bot)
slw += (arc->height >> 1) + 1;
- points = (GdkRectangle*)ALLOCATE_LOCAL(sizeof(GdkRectangle) * slw);
+ points = (GdkSpan*)ALLOCATE_LOCAL(sizeof(GdkSpan) * slw);
if (!points)
return;
pts = points;
ADDSLICESPANS(slice.flip_bot);
}
}
- gdk_fb_fill_spans(pDraw, pGC, points, pts - points);
+ gdk_fb_fill_spans(pDraw, pGC, points, pts - points, FALSE);
DEALLOCATE_LOCAL(points);
}
register int left, right, /* indices to first endpoints */
nextleft,
nextright; /* indices to second endpoints */
- GdkRectangle* ptsOut,
+ GdkSpan* ptsOut,
*FirstPoint; /* output buffer */
imin = GetFPolyYBounds(ptsIn, count, yFtrans, &ymin, &ymax);
y = ymax - ymin + 1;
if ((count < 3) || (y <= 0))
return;
- ptsOut = FirstPoint = (GdkRectangle*)ALLOCATE_LOCAL(sizeof(GdkRectangle) * y);
+ ptsOut = FirstPoint = (GdkSpan*)ALLOCATE_LOCAL(sizeof(GdkSpan) * y);
Marked = (int *) ALLOCATE_LOCAL(sizeof(int) * count);
if(!ptsOut || !Marked)
cxl = ICEIL(xl);
cxr = ICEIL(xr);
- ptsOut->height = 1;
/* reverse the edges if necessary */
if (xl < xr)
{
} while (y <= ymax);
/* Finally, fill the spans we've collected */
- gdk_fb_fill_spans(dst, pgc, FirstPoint, ptsOut-FirstPoint);
+ gdk_fb_fill_spans(dst, pgc, FirstPoint, ptsOut-FirstPoint, TRUE);
DEALLOCATE_LOCAL(Marked);
DEALLOCATE_LOCAL(FirstPoint);
}
register int nPts = 0; /* number of pts in buffer */
register EdgeTableEntry *pWETE; /* Winding Edge Table */
register ScanLineList *pSLL; /* Current ScanLineList */
- register GdkRectangle* ptsOut; /* ptr to output buffers */
- GdkRectangle FirstPoint[NUMPTSTOBUFFER]; /* the output buffers */
+ register GdkSpan* ptsOut; /* ptr to output buffers */
+ GdkSpan FirstPoint[NUMPTSTOBUFFER]; /* the output buffers */
EdgeTableEntry *pPrevAET; /* previous AET entry */
EdgeTable ET; /* Edge Table header node */
EdgeTableEntry AET; /* Active ET header node */
{
ptsOut->x = pAET->bres.minor;
ptsOut->width = pAET->next->bres.minor - pAET->bres.minor;
- ptsOut->height = 1;
ptsOut++->y = y;
nPts++;
*/
if (nPts == NUMPTSTOBUFFER)
{
- gdk_fb_fill_spans(dst, pgc, FirstPoint, nPts);
+ gdk_fb_fill_spans(dst, pgc, FirstPoint, nPts, TRUE);
ptsOut = FirstPoint;
nPts = 0;
}
{
ptsOut->x = pAET->bres.minor;
ptsOut->width = pAET->nextWETE->bres.minor - pAET->bres.minor;
- ptsOut->height = 1;
ptsOut++->y = y;
nPts++;
*/
if (nPts == NUMPTSTOBUFFER)
{
- gdk_fb_fill_spans(dst, pgc, FirstPoint, nPts);
+ gdk_fb_fill_spans(dst, pgc, FirstPoint, nPts, TRUE);
ptsOut = FirstPoint;
nPts = 0;
}
* Get any spans that we missed by buffering
*/
if(nPts > 0)
- gdk_fb_fill_spans(dst, pgc, FirstPoint, nPts);
+ gdk_fb_fill_spans(dst, pgc, FirstPoint, nPts, TRUE);
DEALLOCATE_LOCAL(pETEs);
miFreeStorage(SLLBlock.next);
return(TRUE);
int i, subCount, spansCount;
int ymin, ymax, xmin, xmax;
Spans *spans;
- GdkRectangle* subPt, *spansPt;
+ GdkSpan* subPt, *spansPt;
int extra;
ymin = YMIN(sub);
else
{
if (!extra) {
- GdkRectangle* newPt;
+ GdkSpan* newPt;
#define EXTRA 8
- newPt = (GdkRectangle*) g_realloc (spans->points, (spans->count + EXTRA) * sizeof (GdkRectangle));
+ newPt = (GdkSpan*) g_realloc (spans->points, (spans->count + EXTRA) * sizeof (GdkSpan));
if (!newPt)
break;
spansPt = newPt + (spansPt - spans->points);
spans->count++;
extra--;
spansPt->width = xmin - spansPt->x;
- spansPt->height = 1;
spansPt++;
spansPt->width -= xmax - spansPt->x;
- spansPt->height = 1;
spansPt->x = xmax;
}
}
}
static void QuickSortSpansX(points, numSpans)
- register GdkRectangle points[];
+ register GdkSpan points[];
register int numSpans;
{
register int x;
register int i, j, m;
- register GdkRectangle* r;
+ register GdkSpan* r;
/* Always called with numSpans > 1 */
/* Sorts only by x, as all y should be the same */
#define ExchangeSpans(a, b) \
{ \
- GdkRectangle tpt; \
+ GdkSpan tpt; \
\
tpt = points[a]; points[a] = points[b]; points[b] = tpt; \
}
x = points[i].x;
if (xprev > x) {
/* points[i] is out of order. Move into proper location. */
- GdkRectangle tpt;
+ GdkSpan tpt;
int k;
for (j = 0; x >= points[j].x; j++) {}
static int UniquifySpansX(spans, newPoints, newWidths)
Spans *spans;
- register GdkRectangle *newPoints;
+ register GdkSpan *newPoints;
{
register int newx1, newx2, oldpt, i, y;
- GdkRectangle *oldPoints, *startNewPoints = newPoints;
+ GdkSpan *oldPoints, *startNewPoints = newPoints;
/* Always called with numSpans > 1 */
/* Uniquify the spans, and stash them into newPoints and newWidths. Return the
newPoints->x = newx1;
newPoints->y = y;
newPoints->width = newx2 - newx1;
- newPoints->height = 1;
newPoints++;
newx1 = oldpt;
newx2 = oldpt + oldPoints->width;
/* Write final span */
newPoints->x = newx1;
newPoints->width = newx2 - newx1;
- newPoints->height = 1;
newPoints->y = y;
return (newPoints - startNewPoints) + 1;
register int ymin, ylength;
/* Outgoing spans for one big call to FillSpans */
- register GdkRectangle* points;
+ register GdkSpan* points;
register int count;
if (spanGroup->count == 0) return;
if (spanGroup->count == 1) {
/* Already should be sorted, unique */
spans = spanGroup->group;
- gdk_fb_fill_spans(pDraw, pGC, spans->points, spans->count);
+ gdk_fb_fill_spans(pDraw, pGC, spans->points, spans->count, TRUE);
g_free(spans->points);
}
else
if (index >= 0 && index < ylength) {
Spans *newspans = &(yspans[index]);
if (newspans->count == ysizes[index]) {
- GdkRectangle* newpoints;
+ GdkSpan* newpoints;
ysizes[index] = (ysizes[index] + 8) * 2;
- newpoints = (GdkRectangle*) g_realloc(
+ newpoints = (GdkSpan*) g_realloc(
newspans->points,
- ysizes[index] * sizeof(GdkRectangle));
+ ysizes[index] * sizeof(GdkSpan));
if (!newpoints)
{
int i;
} /* for i thorough Spans */
/* Now sort by x and uniquify each bucket into the final array */
- points = (GdkRectangle*) g_malloc(count * sizeof(GdkRectangle));
+ points = (GdkSpan*) g_malloc(count * sizeof(GdkSpan));
if (!points)
{
int i;
}
}
- gdk_fb_fill_spans(pDraw, pGC, points, count);
+ gdk_fb_fill_spans(pDraw, pGC, points, count, TRUE);
g_free(points);
g_free(yspans);
g_free(ysizes); /* use (DE)ALLOCATE_LOCAL for these? */
register Spans *spans;
for (i = 0, spans = spanGroup->group; i != spanGroup->count; i++, spans++) {
- gdk_fb_fill_spans(pDraw, pGC, spans->points, spans->count);
+ gdk_fb_fill_spans(pDraw, pGC, spans->points, spans->count, TRUE);
g_free(spans->points);
}
typedef struct {
int count; /* number of spans */
- GdkRectangle* points; /* pointer to list of start points */
+ GdkSpan* points; /* pointer to list of start points */
} Spans;
typedef struct {
int height = 0;
int left_height = 0, right_height = 0;
- register GdkRectangle* ppt;
- GdkRectangle* pptInit;
+ register GdkSpan* ppt;
+ GdkSpan* pptInit;
GdkColor oldPixel;
int xorg;
Spans spanRec;
if (!spanData)
{
- pptInit = (GdkRectangle*) ALLOCATE_LOCAL (overall_height * sizeof(*ppt));
+ pptInit = (GdkSpan*) ALLOCATE_LOCAL (overall_height * sizeof(*ppt));
if (!pptInit)
return;
ppt = pptInit;
}
else
{
- spanRec.points = (GdkRectangle*) g_malloc (overall_height * sizeof (*ppt));
+ spanRec.points = (GdkSpan*) g_malloc (overall_height * sizeof (*ppt));
if (!spanRec.points)
return;
ppt = spanRec.points;
ppt->y = y;
ppt->x = left_x + xorg;
ppt->width = right_x - left_x + 1;
- ppt->height = 1;
ppt++;
}
y++;
}
if (!spanData)
{
- gdk_fb_fill_spans(pDrawable, pGC, pptInit, ppt - pptInit);
+ gdk_fb_fill_spans(pDrawable, pGC, pptInit, ppt - pptInit, TRUE);
DEALLOCATE_LOCAL (pptInit);
if (pixel->pixel != oldPixel.pixel)
{
SpanDataPtr spanData;
int x, y, w, h;
{
- register GdkRectangle* ppt;
- GdkColor oldPixel;
+ register GdkSpan* ppt;
+ GdkColor oldPixel;
Spans spanRec;
- GdkRectangle rect;
if (!spanData)
{
- rect.x = x;
- rect.y = y;
- rect.width = w;
- rect.height = h;
oldPixel = GDK_GC_FBDATA(pGC)->values.foreground;
if (pixel->pixel != oldPixel.pixel)
{
gdk_gc_set_foreground(pGC, pixel);
}
- gdk_fb_fill_spans(pDrawable, pGC, &rect, 1);
+ gdk_fb_draw_rectangle(pDrawable, pGC, TRUE, x, y, w, h);
if (pixel->pixel != oldPixel.pixel)
{
gdk_gc_set_foreground(pGC, &oldPixel);
}
else
{
- spanRec.points = (GdkRectangle*) g_malloc (h * sizeof (*ppt));
+ spanRec.points = (GdkSpan*) g_malloc (h * sizeof (*ppt));
if (!spanRec.points)
return;
ppt = spanRec.points;
ppt->x = x;
ppt->y = y;
ppt->width = w;
- ppt->height = 1;
ppt++;
y++;
}
SpanDataPtr spanData;
int x, y;
{
- GdkColor oldPixel;
- GdkRectangle rect;
+ GdkColor oldPixel;
+ GdkSpan span;
MILINESETPIXEL (pDrawable, pGC, pixel, oldPixel);
- rect.width = 1;
- rect.height = 1;
+ span.x = x;
+ span.y = y;
+ span.width = 1;
- gdk_fb_fill_spans(pDrawable, pGC, &rect, 1);
+ gdk_fb_fill_spans(pDrawable, pGC, &span, 1, TRUE);
MILINERESETPIXEL (pDrawable, pGC, pixel, oldPixel);
}
GdkDrawable* pDraw;
GdkGC* pGC;
int xorg, yorg;
- GdkRectangle* points;
+ GdkSpan* points;
{
- register GdkRectangle* tpts, *bpts;
+ register GdkSpan* tpts, *bpts;
register int x, y, e, ex, slw;
tpts = points;
tpts->x = xorg;
tpts->y = yorg;
tpts->width = 1;
- tpts->height = 1;
return 1;
}
bpts = tpts + slw;
tpts->x = xorg - x;
tpts->y = yorg - y;
tpts->width = slw;
- tpts->height = 1;
tpts++;
if ((y != 0) && ((slw > 1) || (e != ex)))
{
bpts--;
bpts->x = xorg - x;
bpts->y = yorg + y;
- bpts->height = 1;
bpts->width = slw;
}
}
GdkDrawable* pDraw;
GdkGC* pGC;
double xorg, yorg;
- GdkRectangle* points;
+ GdkSpan* points;
PolyEdgePtr edge1, edge2;
int edgey1, edgey2;
gboolean edgeleft1, edgeleft2;
{
- register GdkRectangle* pts;
+ register GdkSpan* pts;
double radius, x0, y0, el, er, yk, xlk, xrk, k;
int xbase, ybase, y, boty, xl, xr, xcl, xcr;
int ymin, ymax;
pts->x = xcl;
pts->y = ybase;
pts->width = xcr - xcl + 1;
- pts->height = 1;
pts++;
}
}
pts->x = xcl;
pts->y = ybase;
pts->width = xcr - xcl + 1;
- pts->height = 1;
pts++;
}
}
double xorg, yorg;
gboolean isInt;
{
- GdkRectangle* points;
+ GdkSpan* points;
int xorgi = 0, yorgi = 0;
GdkColor oldPixel;
Spans spanRec;
}
if (!spanData)
{
- points = (GdkRectangle*)ALLOCATE_LOCAL(sizeof(GdkRectangle) * GDK_GC_FBDATA(pGC)->values.line_width);
+ points = (GdkSpan*)ALLOCATE_LOCAL(sizeof(GdkSpan) * GDK_GC_FBDATA(pGC)->values.line_width);
if (!points)
return;
oldPixel = GDK_GC_FBDATA(pGC)->values.foreground;
}
else
{
- points = (GdkRectangle*) g_malloc (GDK_GC_FBDATA(pGC)->values.line_width * sizeof (GdkRectangle));
+ points = (GdkSpan*) g_malloc (GDK_GC_FBDATA(pGC)->values.line_width * sizeof (GdkSpan));
if (!points)
return;
spanRec.points = points;
if (!spanData)
{
- gdk_fb_fill_spans(pDraw, pGC, points, n);
+ gdk_fb_fill_spans(pDraw, pGC, points, n, TRUE);
DEALLOCATE_LOCAL(points);
if (pixel->pixel != oldPixel.pixel)
{
spans->x = xx;\
spans->y = yy;\
spans->width = 1; \
- spans->height = 1; \
current_y = yy;\
new_span = FALSE;\
}\
{
int Nspans, current_y;
GdkPoint* ppt;
- GdkRectangle* pspanInit, *spans;
+ GdkSpan* pspanInit, *spans;
int list_len;
int xleft, ytop, xright, ybottom;
int new_x1, new_y1, new_x2, new_y2;
width = xright - xleft + 1;
height = ybottom - ytop + 1;
list_len = (height >= width) ? height : width;
- pspanInit = (GdkRectangle*)ALLOCATE_LOCAL(list_len * sizeof(GdkRectangle));
+ pspanInit = (GdkSpan*)ALLOCATE_LOCAL(list_len * sizeof(GdkSpan));
if (!pspanInit)
return;
while (--npt > 0)
{
if (Nspans > 0)
- gdk_fb_fill_spans(pDraw, pGC, pspanInit, Nspans);
+ gdk_fb_fill_spans(pDraw, pGC, pspanInit, Nspans, FALSE);
Nspans = 0;
new_span = TRUE;
spans = pspanInit - 1;
}
if (Nspans > 0)
- gdk_fb_fill_spans(pDraw, pGC, pspanInit, Nspans);
+ gdk_fb_fill_spans(pDraw, pGC, pspanInit, Nspans, FALSE);
DEALLOCATE_LOCAL(pspanInit);
}
projects / gtk4.git / commitdiff